sql_select.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:288k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. if (item->maybe_null)
  2. {
  3.   Field *field=item->get_tmp_table_field();
  4.   field->ptr[-1]= (byte) (field->is_null() ? 1 : 0);
  5. }
  6.       }
  7.     }
  8. #endif
  9.     if (!join->having || join->having->val_int())
  10.     {
  11.       join->found_records++;
  12.       if ((error=table->file->write_row(table->record[0])))
  13.       {
  14. if (error == HA_ERR_FOUND_DUPP_KEY ||
  15.     error == HA_ERR_FOUND_DUPP_UNIQUE)
  16.   goto end;
  17. if (create_myisam_from_heap(join->thd, table, &join->tmp_table_param,
  18.     error,1))
  19.   DBUG_RETURN(-1); // Not a table_is_full error
  20. table->uniques=0; // To ensure rows are the same
  21.       }
  22.       if (++join->send_records >= join->tmp_table_param.end_write_records &&
  23.   join->do_send_rows)
  24.       {
  25. if (!(join->select_options & OPTION_FOUND_ROWS))
  26.   DBUG_RETURN(-3);
  27. join->do_send_rows=0;
  28. join->unit->select_limit_cnt = HA_POS_ERROR;
  29. DBUG_RETURN(0);
  30.       }
  31.     }
  32.   }
  33. end:
  34.   DBUG_RETURN(0);
  35. }
  36. /* Group by searching after group record and updating it if possible */
  37. /* ARGSUSED */
  38. static int
  39. end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
  40.    bool end_of_records)
  41. {
  42.   TABLE *table=join->tmp_table;
  43.   ORDER   *group;
  44.   int   error;
  45.   DBUG_ENTER("end_update");
  46.   if (end_of_records)
  47.     DBUG_RETURN(0);
  48.   if (join->thd->killed) // Aborted by user
  49.   {
  50.     my_error(ER_SERVER_SHUTDOWN,MYF(0)); /* purecov: inspected */
  51.     DBUG_RETURN(-2); /* purecov: inspected */
  52.   }
  53.   join->found_records++;
  54.   copy_fields(&join->tmp_table_param); // Groups are copied twice.
  55.   /* Make a key of group index */
  56.   for (group=table->group ; group ; group=group->next)
  57.   {
  58.     Item *item= *group->item;
  59.     item->save_org_in_field(group->field);
  60. #ifdef EMBEDDED_LIBRARY
  61.     join->thd->net.last_errno= 0;
  62. #endif
  63.     /* Store in the used key if the field was 0 */
  64.     if (item->maybe_null)
  65.       group->buff[-1]=item->null_value ? 1 : 0;
  66.   }
  67.   if (!table->file->index_read(table->record[1],
  68.        join->tmp_table_param.group_buff,0,
  69.        HA_READ_KEY_EXACT))
  70.   { /* Update old record */
  71.     restore_record(table,record[1]);
  72.     update_tmptable_sum_func(join->sum_funcs,table);
  73.     if ((error=table->file->update_row(table->record[1],
  74.        table->record[0])))
  75.     {
  76.       table->file->print_error(error,MYF(0)); /* purecov: inspected */
  77.       DBUG_RETURN(-1); /* purecov: inspected */
  78.     }
  79.     DBUG_RETURN(0);
  80.   }
  81.   /* The null bits are already set */
  82.   KEY_PART_INFO *key_part;
  83.   for (group=table->group,key_part=table->key_info[0].key_part;
  84.        group ;
  85.        group=group->next,key_part++)
  86.     memcpy(table->record[0]+key_part->offset, group->buff, key_part->length);
  87.   init_tmptable_sum_functions(join->sum_funcs);
  88.   copy_funcs(join->tmp_table_param.items_to_copy);
  89.   if ((error=table->file->write_row(table->record[0])))
  90.   {
  91.     if (create_myisam_from_heap(join->thd, table, &join->tmp_table_param,
  92. error, 0))
  93.       DBUG_RETURN(-1); // Not a table_is_full error
  94.     /* Change method to update rows */
  95.     table->file->ha_index_init(0);
  96.     join->join_tab[join->tables-1].next_select=end_unique_update;
  97.   }
  98.   join->send_records++;
  99.   DBUG_RETURN(0);
  100. }
  101. /* Like end_update, but this is done with unique constraints instead of keys */
  102. static int
  103. end_unique_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
  104.   bool end_of_records)
  105. {
  106.   TABLE *table=join->tmp_table;
  107.   int   error;
  108.   DBUG_ENTER("end_unique_update");
  109.   if (end_of_records)
  110.     DBUG_RETURN(0);
  111.   if (join->thd->killed) // Aborted by user
  112.   {
  113.     my_error(ER_SERVER_SHUTDOWN,MYF(0)); /* purecov: inspected */
  114.     DBUG_RETURN(-2); /* purecov: inspected */
  115.   }
  116.   init_tmptable_sum_functions(join->sum_funcs);
  117.   copy_fields(&join->tmp_table_param); // Groups are copied twice.
  118.   copy_funcs(join->tmp_table_param.items_to_copy);
  119.   if (!(error=table->file->write_row(table->record[0])))
  120.     join->send_records++; // New group
  121.   else
  122.   {
  123.     if ((int) table->file->get_dup_key(error) < 0)
  124.     {
  125.       table->file->print_error(error,MYF(0)); /* purecov: inspected */
  126.       DBUG_RETURN(-1); /* purecov: inspected */
  127.     }
  128.     if (table->file->rnd_pos(table->record[1],table->file->dupp_ref))
  129.     {
  130.       table->file->print_error(error,MYF(0)); /* purecov: inspected */
  131.       DBUG_RETURN(-1); /* purecov: inspected */
  132.     }
  133.     restore_record(table,record[1]);
  134.     update_tmptable_sum_func(join->sum_funcs,table);
  135.     if ((error=table->file->update_row(table->record[1],
  136.        table->record[0])))
  137.     {
  138.       table->file->print_error(error,MYF(0)); /* purecov: inspected */
  139.       DBUG_RETURN(-1); /* purecov: inspected */
  140.     }
  141.   }
  142.   DBUG_RETURN(0);
  143. }
  144. /* ARGSUSED */
  145. static int
  146. end_write_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
  147. bool end_of_records)
  148. {
  149.   TABLE *table=join->tmp_table;
  150.   int   error;
  151.   int   idx= -1;
  152.   DBUG_ENTER("end_write_group");
  153.   if (join->thd->killed)
  154.   { // Aborted by user
  155.     my_error(ER_SERVER_SHUTDOWN,MYF(0)); /* purecov: inspected */
  156.     DBUG_RETURN(-2); /* purecov: inspected */
  157.   }
  158.   if (!join->first_record || end_of_records ||
  159.       (idx=test_if_group_changed(join->group_fields)) >= 0)
  160.   {
  161.     if (join->first_record || (end_of_records && !join->group))
  162.     {
  163.       if (join->procedure)
  164. join->procedure->end_group();
  165.       int send_group_parts= join->send_group_parts;
  166.       if (idx < send_group_parts)
  167.       {
  168. if (!join->first_record)
  169. {
  170.   /* No matching rows for group function */
  171.   join->clear();
  172. }
  173.         copy_sum_funcs(join->sum_funcs,
  174.                        join->sum_funcs_end[send_group_parts]);
  175. if (join->having && join->having->val_int() == 0)
  176.           error= -1;
  177.         else if ((error=table->file->write_row(table->record[0])))
  178. {
  179.   if (create_myisam_from_heap(join->thd, table,
  180.       &join->tmp_table_param,
  181.       error, 0))
  182.     DBUG_RETURN(-1);        
  183.             /* 
  184.               If table->file->write_row() was failed because of 'out of memory'
  185.               and tmp table succesfully created, reset error.
  186.              */
  187.             error=0;
  188.         }
  189.         if (join->rollup.state != ROLLUP::STATE_NONE && error <= 0)
  190. {
  191.   if (join->rollup_write_data((uint) (idx+1), table))
  192.     error= 1;
  193. }
  194. if (error > 0)
  195.   DBUG_RETURN(-1);   
  196. if (end_of_records)
  197.   DBUG_RETURN(0);
  198.       }
  199.     }
  200.     else
  201.     {
  202.       if (end_of_records)
  203. DBUG_RETURN(0);
  204.       join->first_record=1;
  205.       VOID(test_if_group_changed(join->group_fields));
  206.     }
  207.     if (idx < (int) join->send_group_parts)
  208.     {
  209.       copy_fields(&join->tmp_table_param);
  210.       copy_funcs(join->tmp_table_param.items_to_copy);
  211.       if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1]))
  212. DBUG_RETURN(-1);
  213.       if (join->procedure)
  214. join->procedure->add();
  215.       DBUG_RETURN(0);
  216.     }
  217.   }
  218.   if (update_sum_func(join->sum_funcs))
  219.     DBUG_RETURN(-1);
  220.   if (join->procedure)
  221.     join->procedure->add();
  222.   DBUG_RETURN(0);
  223. }
  224. /*****************************************************************************
  225.   Remove calculation with tables that aren't yet read. Remove also tests
  226.   against fields that are read through key where the table is not a
  227.   outer join table.
  228.   We can't remove tests that are made against columns which are stored
  229.   in sorted order.
  230. *****************************************************************************/
  231. /* Return 1 if right_item is used removable reference key on left_item */
  232. static bool test_if_ref(Item_field *left_item,Item *right_item)
  233. {
  234.   Field *field=left_item->field;
  235.   // No need to change const test. We also have to keep tests on LEFT JOIN
  236.   if (!field->table->const_table && !field->table->maybe_null)
  237.   {
  238.     Item *ref_item=part_of_refkey(field->table,field);
  239.     if (ref_item && ref_item->eq(right_item,1))
  240.     {
  241.       if (right_item->type() == Item::FIELD_ITEM)
  242. return (field->eq_def(((Item_field *) right_item)->field));
  243.       if (right_item->const_item() && !(right_item->is_null()))
  244.       {
  245. /*
  246.   We can remove binary fields and numerical fields except float,
  247.   as float comparison isn't 100 % secure
  248.   We have to keep binary strings to be able to check for end spaces
  249. */
  250. if (field->binary() &&
  251.     field->real_type() != FIELD_TYPE_STRING &&
  252.     field->real_type() != FIELD_TYPE_VAR_STRING &&
  253.     (field->type() != FIELD_TYPE_FLOAT || field->decimals() == 0))
  254. {
  255.   return !store_val_in_field(field,right_item);
  256. }
  257.       }
  258.     }
  259.   }
  260.   return 0; // keep test
  261. }
  262. static COND *
  263. make_cond_for_table(COND *cond, table_map tables, table_map used_table)
  264. {
  265.   if (used_table && !(cond->used_tables() & used_table))
  266.     return (COND*) 0; // Already checked
  267.   if (cond->type() == Item::COND_ITEM)
  268.   {
  269.     if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
  270.     {
  271.       /* Create new top level AND item */
  272.       Item_cond_and *new_cond=new Item_cond_and;
  273.       if (!new_cond)
  274. return (COND*) 0; // OOM /* purecov: inspected */
  275.       List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
  276.       Item *item;
  277.       while ((item=li++))
  278.       {
  279. Item *fix=make_cond_for_table(item,tables,used_table);
  280. if (fix)
  281.   new_cond->argument_list()->push_back(fix);
  282.       }
  283.       switch (new_cond->argument_list()->elements) {
  284.       case 0:
  285. return (COND*) 0; // Always true
  286.       case 1:
  287. return new_cond->argument_list()->head();
  288.       default:
  289. /*
  290.   Item_cond_and do not need fix_fields for execution, its parameters
  291.   are fixed or do not need fix_fields, too
  292. */
  293. new_cond->quick_fix_field();
  294. new_cond->used_tables_cache=
  295.   ((Item_cond_and*) cond)->used_tables_cache &
  296.   tables;
  297. return new_cond;
  298.       }
  299.     }
  300.     else
  301.     { // Or list
  302.       Item_cond_or *new_cond=new Item_cond_or;
  303.       if (!new_cond)
  304. return (COND*) 0; // OOM /* purecov: inspected */
  305.       List_iterator<Item> li(*((Item_cond*) cond)->argument_list());
  306.       Item *item;
  307.       while ((item=li++))
  308.       {
  309. Item *fix=make_cond_for_table(item,tables,0L);
  310. if (!fix)
  311.   return (COND*) 0; // Always true
  312. new_cond->argument_list()->push_back(fix);
  313.       }
  314.       /*
  315. Item_cond_and do not need fix_fields for execution, its parameters
  316. are fixed or do not need fix_fields, too
  317.       */
  318.       new_cond->quick_fix_field();
  319.       new_cond->used_tables_cache= ((Item_cond_or*) cond)->used_tables_cache;
  320.       new_cond->top_level_item();
  321.       return new_cond;
  322.     }
  323.   }
  324.   /*
  325.     Because the following test takes a while and it can be done
  326.     table_count times, we mark each item that we have examined with the result
  327.     of the test
  328.   */
  329.   if (cond->marker == 3 || (cond->used_tables() & ~tables))
  330.     return (COND*) 0; // Can't check this yet
  331.   if (cond->marker == 2 || cond->eq_cmp_result() == Item::COND_OK)
  332.     return cond; // Not boolean op
  333.   if (((Item_func*) cond)->functype() == Item_func::EQ_FUNC)
  334.   {
  335.     Item *left_item= ((Item_func*) cond)->arguments()[0];
  336.     Item *right_item= ((Item_func*) cond)->arguments()[1];
  337.     if (left_item->type() == Item::FIELD_ITEM &&
  338. test_if_ref((Item_field*) left_item,right_item))
  339.     {
  340.       cond->marker=3; // Checked when read
  341.       return (COND*) 0;
  342.     }
  343.     if (right_item->type() == Item::FIELD_ITEM &&
  344. test_if_ref((Item_field*) right_item,left_item))
  345.     {
  346.       cond->marker=3; // Checked when read
  347.       return (COND*) 0;
  348.     }
  349.   }
  350.   cond->marker=2;
  351.   return cond;
  352. }
  353. static Item *
  354. part_of_refkey(TABLE *table,Field *field)
  355. {
  356.   if (!table->reginfo.join_tab)
  357.     return (Item*) 0;             // field from outer non-select (UPDATE,...)
  358.   uint ref_parts=table->reginfo.join_tab->ref.key_parts;
  359.   if (ref_parts)
  360.   {
  361.     KEY_PART_INFO *key_part=
  362.       table->key_info[table->reginfo.join_tab->ref.key].key_part;
  363.     for (uint part=0 ; part < ref_parts ; part++,key_part++)
  364.       if (field->eq(key_part->field) &&
  365.   !(key_part->key_part_flag & HA_PART_KEY_SEG))
  366. return table->reginfo.join_tab->ref.items[part];
  367.   }
  368.   return (Item*) 0;
  369. }
  370. /*****************************************************************************
  371.   Test if one can use the key to resolve ORDER BY
  372.   SYNOPSIS
  373.     test_if_order_by_key()
  374.     order Sort order
  375.     table Table to sort
  376.     idx Index to check
  377.     used_key_parts Return value for used key parts.
  378.   NOTES
  379.     used_key_parts is set to correct key parts used if return value != 0
  380.     (On other cases, used_key_part may be changed)
  381.   RETURN
  382.     1   key is ok.
  383.     0   Key can't be used
  384.     -1  Reverse key can be used
  385. *****************************************************************************/
  386. static int test_if_order_by_key(ORDER *order, TABLE *table, uint idx,
  387. uint *used_key_parts)
  388. {
  389.   KEY_PART_INFO *key_part,*key_part_end;
  390.   key_part=table->key_info[idx].key_part;
  391.   key_part_end=key_part+table->key_info[idx].key_parts;
  392.   key_part_map const_key_parts=table->const_key_parts[idx];
  393.   int reverse=0;
  394.   DBUG_ENTER("test_if_order_by_key");
  395.   for (; order ; order=order->next, const_key_parts>>=1)
  396.   {
  397.     Field *field=((Item_field*) (*order->item))->field;
  398.     int flag;
  399.     /*
  400.       Skip key parts that are constants in the WHERE clause.
  401.       These are already skipped in the ORDER BY by const_expression_in_where()
  402.     */
  403.     for (; const_key_parts & 1 ; const_key_parts>>= 1)
  404.       key_part++; 
  405.     if (key_part == key_part_end || key_part->field != field)
  406.       DBUG_RETURN(0);
  407.     /* set flag to 1 if we can use read-next on key, else to -1 */
  408.     flag= ((order->asc == !(key_part->key_part_flag & HA_REVERSE_SORT)) ?
  409.            1 : -1);
  410.     if (reverse && flag != reverse)
  411.       DBUG_RETURN(0);
  412.     reverse=flag; // Remember if reverse
  413.     key_part++;
  414.   }
  415.   *used_key_parts= (uint) (key_part - table->key_info[idx].key_part);
  416.   if (reverse == -1 && !(table->file->index_flags(idx, *used_key_parts-1, 1) &
  417.                          HA_READ_PREV))
  418.     reverse= 0;                                 // Index can't be used
  419.   DBUG_RETURN(reverse);
  420. }
  421. static uint find_shortest_key(TABLE *table, const key_map *usable_keys)
  422. {
  423.   uint min_length= (uint) ~0;
  424.   uint best= MAX_KEY;
  425.   if (!usable_keys->is_clear_all())
  426.   {
  427.     for (uint nr=0; nr < table->keys ; nr++)
  428.     {
  429.       if (usable_keys->is_set(nr))
  430.       {
  431.         if (table->key_info[nr].key_length < min_length)
  432.         {
  433.           min_length=table->key_info[nr].key_length;
  434.           best=nr;
  435.         }
  436.       }
  437.     }
  438.   }
  439.   return best;
  440. }
  441. /*
  442.   Test if a second key is the subkey of the first one.
  443.   SYNOPSIS
  444.     is_subkey()
  445.     key_part First key parts
  446.     ref_key_part Second key parts
  447.     ref_key_part_end Last+1 part of the second key
  448.   NOTE
  449.     Second key MUST be shorter than the first one.
  450.   RETURN
  451.     1 is a subkey
  452.     0 no sub key
  453. */
  454. inline bool 
  455. is_subkey(KEY_PART_INFO *key_part, KEY_PART_INFO *ref_key_part,
  456.   KEY_PART_INFO *ref_key_part_end)
  457. {
  458.   for (; ref_key_part < ref_key_part_end; key_part++, ref_key_part++)
  459.     if (!key_part->field->eq(ref_key_part->field))
  460.       return 0;
  461.   return 1;
  462. }
  463. /*
  464.   Test if we can use one of the 'usable_keys' instead of 'ref' key for sorting
  465.   SYNOPSIS
  466.     test_if_subkey()
  467.     ref Number of key, used for WHERE clause
  468.     usable_keys Keys for testing
  469.   RETURN
  470.     MAX_KEY If we can't use other key
  471.     the number of found key Otherwise
  472. */
  473. static uint
  474. test_if_subkey(ORDER *order, TABLE *table, uint ref, uint ref_key_parts,
  475.        const key_map *usable_keys)
  476. {
  477.   uint nr;
  478.   uint min_length= (uint) ~0;
  479.   uint best= MAX_KEY;
  480.   uint not_used;
  481.   KEY_PART_INFO *ref_key_part= table->key_info[ref].key_part;
  482.   KEY_PART_INFO *ref_key_part_end= ref_key_part + ref_key_parts;
  483.   for (nr= 0 ; nr < table->keys ; nr++)
  484.   {
  485.     if (usable_keys->is_set(nr) &&
  486. table->key_info[nr].key_length < min_length &&
  487. table->key_info[nr].key_parts >= ref_key_parts &&
  488. is_subkey(table->key_info[nr].key_part, ref_key_part,
  489.   ref_key_part_end) &&
  490. test_if_order_by_key(order, table, nr, &not_used))
  491.     {
  492.       min_length= table->key_info[nr].key_length;
  493.       best= nr;
  494.     }
  495.   }
  496.   return best;
  497. }
  498. /*
  499.   Test if we can skip the ORDER BY by using an index.
  500.   If we can use an index, the JOIN_TAB / tab->select struct
  501.   is changed to use the index.
  502.   Return:
  503.      0 We have to use filesort to do the sorting
  504.      1 We can use an index.
  505. */
  506. static bool
  507. test_if_skip_sort_order(JOIN_TAB *tab,ORDER *order,ha_rows select_limit,
  508. bool no_changes)
  509. {
  510.   int ref_key;
  511.   uint ref_key_parts;
  512.   TABLE *table=tab->table;
  513.   SQL_SELECT *select=tab->select;
  514.   key_map usable_keys;
  515.   DBUG_ENTER("test_if_skip_sort_order");
  516.   LINT_INIT(ref_key_parts);
  517.   /*
  518.     Check which keys can be used to resolve ORDER BY.
  519.     We must not try to use disabled keys.
  520.   */
  521.   usable_keys= table->keys_in_use;
  522.   for (ORDER *tmp_order=order; tmp_order ; tmp_order=tmp_order->next)
  523.   {
  524.     if ((*tmp_order->item)->type() != Item::FIELD_ITEM)
  525.     {
  526.       usable_keys.clear_all();
  527.       DBUG_RETURN(0);
  528.     }
  529.     usable_keys.intersect(((Item_field*) (*tmp_order->item))->
  530.   field->part_of_sortkey);
  531.     if (usable_keys.is_clear_all())
  532.       DBUG_RETURN(0); // No usable keys
  533.   }
  534.   ref_key= -1;
  535.   /* Test if constant range in WHERE */
  536.   if (tab->ref.key >= 0 && tab->ref.key_parts)
  537.   {
  538.     ref_key=    tab->ref.key;
  539.     ref_key_parts= tab->ref.key_parts;
  540.     if (tab->type == JT_REF_OR_NULL || tab->type == JT_FT)
  541.       DBUG_RETURN(0);
  542.   }
  543.   else if (select && select->quick) // Range found by opt_range
  544.   {
  545.     ref_key=    select->quick->index;
  546.     ref_key_parts= select->quick->used_key_parts;
  547.   }
  548.   if (ref_key >= 0)
  549.   {
  550.     /*
  551.       We come here when there is a REF key.
  552.     */
  553.     int order_direction;
  554.     uint used_key_parts;
  555.     if (!usable_keys.is_set(ref_key))
  556.     {
  557.       /*
  558. We come here when ref_key is not among usable_keys
  559.       */
  560.       uint new_ref_key;
  561.       /*
  562. If using index only read, only consider other possible index only
  563. keys
  564.       */
  565.       if (table->used_keys.is_set(ref_key))
  566. usable_keys.intersect(table->used_keys);
  567.       if ((new_ref_key= test_if_subkey(order, table, ref_key, ref_key_parts,
  568.        &usable_keys)) < MAX_KEY)
  569.       {
  570. /* Found key that can be used to retrieve data in sorted order */
  571. if (tab->ref.key >= 0)
  572. {
  573.           /*
  574.             We'll use ref access method on key new_ref_key. In general case 
  575.             the index search tuple for new_ref_key will be different (e.g.
  576.             when one index is defined as (part1, part2, ...) and another as
  577.             (part1, part2(N), ...) and the WHERE clause contains 
  578.             "part1 = const1 AND part2=const2". 
  579.             So we build tab->ref from scratch here.
  580.           */
  581.           KEYUSE *keyuse= tab->keyuse;
  582.           while (keyuse->key != new_ref_key && keyuse->table == tab->table)
  583.             keyuse++;
  584.           if (create_ref_for_key(tab->join, tab, keyuse, 
  585.                                  tab->join->const_table_map))
  586.             DBUG_RETURN(0);
  587. }
  588. else
  589. {
  590.           /*
  591.             The range optimizer constructed QUICK_RANGE for ref_key, and
  592.             we want to use instead new_ref_key as the index. We can't
  593.             just change the index of the quick select, because this may
  594.             result in an incosistent QUICK_SELECT object. Below we
  595.             create a new QUICK_SELECT from scratch so that all its
  596.             parameres are set correctly by the range optimizer.
  597.            */
  598.           key_map new_ref_key_map;
  599.           new_ref_key_map.clear_all();  // Force the creation of quick select
  600.           new_ref_key_map.set_bit(new_ref_key); // only for new_ref_key.
  601.           if (select->test_quick_select(tab->join->thd, new_ref_key_map, 0,
  602.                                         (tab->join->select_options &
  603.                                          OPTION_FOUND_ROWS) ?
  604.                                         HA_POS_ERROR :
  605.                                         tab->join->unit->select_limit_cnt,0) <=
  606.               0)
  607.             DBUG_RETURN(0);
  608. }
  609.         ref_key= new_ref_key;
  610.       }
  611.     }
  612.     /* Check if we get the rows in requested sorted order by using the key */
  613.     if (usable_keys.is_set(ref_key) &&
  614. (order_direction = test_if_order_by_key(order,table,ref_key,
  615. &used_key_parts)))
  616.     {
  617.       if (order_direction == -1) // If ORDER BY ... DESC
  618.       {
  619. if (select && select->quick)
  620. {
  621.   /*
  622.     Don't reverse the sort order, if it's already done.
  623.     (In some cases test_if_order_by_key() can be called multiple times
  624.   */
  625.   if (!select->quick->reverse_sorted())
  626.   {
  627.     // ORDER BY range_key DESC
  628.     QUICK_SELECT_DESC *tmp=new QUICK_SELECT_DESC(select->quick,
  629.  used_key_parts);
  630.     if (!tmp || tmp->error)
  631.     {
  632.       delete tmp;
  633.       DBUG_RETURN(0); // Reverse sort not supported
  634.     }
  635.     select->quick=tmp;
  636.   }
  637.   DBUG_RETURN(1);
  638. }
  639. if (tab->ref.key_parts < used_key_parts)
  640. {
  641.   /*
  642.     SELECT * FROM t1 WHERE a=1 ORDER BY a DESC,b DESC
  643.     Use a traversal function that starts by reading the last row
  644.     with key part (A) and then traverse the index backwards.
  645.   */
  646.   tab->read_first_record=       join_read_last_key;
  647.   tab->read_record.read_record= join_read_prev_same;
  648.   /* fall through */
  649. }
  650.       }
  651.       else if (select && select->quick)
  652.   select->quick->sorted= 1;
  653.       DBUG_RETURN(1); /* No need to sort */
  654.     }
  655.   }
  656.   else
  657.   {
  658.     /* check if we can use a key to resolve the group */
  659.     /* Tables using JT_NEXT are handled here */
  660.     uint nr;
  661.     key_map keys;
  662.     /*
  663.       If not used with LIMIT, only use keys if the whole query can be
  664.       resolved with a key;  This is because filesort() is usually faster than
  665.       retrieving all rows through an index.
  666.     */
  667.     if (select_limit >= table->file->records)
  668.     {
  669.       keys= *table->file->keys_to_use_for_scanning();
  670.       keys.merge(table->used_keys);
  671.       /*
  672. We are adding here also the index specified in FORCE INDEX clause, 
  673. if any.
  674.         This is to allow users to use index in ORDER BY.
  675.       */
  676.       if (table->force_index) 
  677. keys.merge(table->keys_in_use_for_query);
  678.       keys.intersect(usable_keys);
  679.     }
  680.     else
  681.       keys= usable_keys;
  682.     for (nr=0; nr < table->keys ; nr++)
  683.     {
  684.       uint not_used;
  685.       if (keys.is_set(nr))
  686.       {
  687. int flag;
  688. if ((flag= test_if_order_by_key(order, table, nr, &not_used)))
  689. {
  690.   if (!no_changes)
  691.   {
  692.     tab->index=nr;
  693.     tab->read_first_record=  (flag > 0 ? join_read_first:
  694.       join_read_last);
  695.     tab->type=JT_NEXT; // Read with index_first(), index_next()
  696.     if (table->used_keys.is_set(nr))
  697.     {
  698.       table->key_read=1;
  699.       table->file->extra(HA_EXTRA_KEYREAD);
  700.     }
  701.   }
  702.   DBUG_RETURN(1);
  703. }
  704.       }
  705.     }
  706.   }
  707.   DBUG_RETURN(0); // Can't use index.
  708. }
  709. /*
  710.   If not selecting by given key, create an index how records should be read
  711.   SYNOPSIS
  712.    create_sort_index()
  713.      thd Thread handler
  714.      tab Table to sort (in join structure)
  715.      order How table should be sorted
  716.      filesort_limit Max number of rows that needs to be sorted
  717.      select_limit Max number of rows in final output
  718.         Used to decide if we should use index or not
  719.   IMPLEMENTATION
  720.    - If there is an index that can be used, 'tab' is modified to use
  721.      this index.
  722.    - If no index, create with filesort() an index file that can be used to
  723.      retrieve rows in order (should be done with 'read_record').
  724.      The sorted data is stored in tab->table and will be freed when calling
  725.      free_io_cache(tab->table).
  726.   RETURN VALUES
  727.     0 ok
  728.     -1 Some fatal error
  729.     1 No records
  730. */
  731. static int
  732. create_sort_index(THD *thd, JOIN *join, ORDER *order,
  733.   ha_rows filesort_limit, ha_rows select_limit)
  734. {
  735.   SORT_FIELD *sortorder;
  736.   uint length;
  737.   ha_rows examined_rows;
  738.   TABLE *table;
  739.   SQL_SELECT *select;
  740.   JOIN_TAB *tab;
  741.   DBUG_ENTER("create_sort_index");
  742.   if (join->tables == join->const_tables)
  743.     DBUG_RETURN(0); // One row, no need to sort
  744.   tab=    join->join_tab + join->const_tables;
  745.   table=  tab->table;
  746.   select= tab->select;
  747.   if (test_if_skip_sort_order(tab,order,select_limit,0))
  748.     DBUG_RETURN(0);
  749.   if (!(sortorder=make_unireg_sortorder(order,&length)))
  750.     goto err; /* purecov: inspected */
  751.   /* It's not fatal if the following alloc fails */
  752.   table->sort.io_cache=(IO_CACHE*) my_malloc(sizeof(IO_CACHE),
  753.                                              MYF(MY_WME | MY_ZEROFILL));
  754.   table->status=0; // May be wrong if quick_select
  755.   // If table has a range, move it to select
  756.   if (select && !select->quick && tab->ref.key >= 0)
  757.   {
  758.     if (tab->quick)
  759.     {
  760.       select->quick=tab->quick;
  761.       tab->quick=0;
  762.       /* We can only use 'Only index' if quick key is same as ref_key */
  763.       if (table->key_read && (uint) tab->ref.key != select->quick->index)
  764.       {
  765. table->key_read=0;
  766. table->file->extra(HA_EXTRA_NO_KEYREAD);
  767.       }
  768.     }
  769.     else
  770.     {
  771.       /*
  772. We have a ref on a const;  Change this to a range that filesort
  773. can use.
  774. For impossible ranges (like when doing a lookup on NULL on a NOT NULL
  775. field, quick will contain an empty record set.
  776.       */
  777.       if (!(select->quick= (tab->type == JT_FT ?
  778.     new FT_SELECT(thd, table, tab->ref.key) :
  779.     get_quick_select_for_ref(thd, table, &tab->ref))))
  780. goto err;
  781.     }
  782.   }
  783.   if (table->tmp_table)
  784.     table->file->info(HA_STATUS_VARIABLE); // Get record count
  785.   table->sort.found_records=filesort(thd, table,sortorder, length,
  786.                                      select, filesort_limit, &examined_rows);
  787.   tab->records= table->sort.found_records; // For SQL_CALC_ROWS
  788.   if (select)
  789.   {
  790.     select->cleanup(); // filesort did select
  791.     tab->select= 0;
  792.   }
  793.   tab->select_cond=0;
  794.   tab->type=JT_ALL; // Read with normal read_record
  795.   tab->read_first_record= join_init_read_record;
  796.   tab->join->examined_rows+=examined_rows;
  797.   if (table->key_read) // Restore if we used indexes
  798.   {
  799.     table->key_read=0;
  800.     table->file->extra(HA_EXTRA_NO_KEYREAD);
  801.   }
  802.   DBUG_RETURN(table->sort.found_records == HA_POS_ERROR);
  803. err:
  804.   DBUG_RETURN(-1);
  805. }
  806. /*
  807.   Add the HAVING criteria to table->select
  808. */
  809. #ifdef NOT_YET
  810. static bool fix_having(JOIN *join, Item **having)
  811. {
  812.   (*having)->update_used_tables(); // Some tables may have been const
  813.   JOIN_TAB *table=&join->join_tab[join->const_tables];
  814.   table_map used_tables= join->const_table_map | table->table->map;
  815.   DBUG_EXECUTE("where",print_where(*having,"having"););
  816.   Item* sort_table_cond=make_cond_for_table(*having,used_tables,used_tables);
  817.   if (sort_table_cond)
  818.   {
  819.     if (!table->select)
  820.       if (!(table->select=new SQL_SELECT))
  821. return 1;
  822.     if (!table->select->cond)
  823.       table->select->cond=sort_table_cond;
  824.     else // This should never happen
  825.       if (!(table->select->cond= new Item_cond_and(table->select->cond,
  826.    sort_table_cond)) ||
  827.   table->select->cond->fix_fields(join->thd, join->tables_list,
  828.   &table->select->cond))
  829. return 1;
  830.     table->select_cond=table->select->cond;
  831.     table->select_cond->top_level_item();
  832.     DBUG_EXECUTE("where",print_where(table->select_cond,
  833.      "select and having"););
  834.     *having=make_cond_for_table(*having,~ (table_map) 0,~used_tables);
  835.     DBUG_EXECUTE("where",print_where(*having,"having after make_cond"););
  836.   }
  837.   return 0;
  838. }
  839. #endif
  840. /*****************************************************************************
  841.   Remove duplicates from tmp table
  842.   This should be recoded to add a unique index to the table and remove
  843.   duplicates
  844.   Table is a locked single thread table
  845.   fields is the number of fields to check (from the end)
  846. *****************************************************************************/
  847. static bool compare_record(TABLE *table, Field **ptr)
  848. {
  849.   for (; *ptr ; ptr++)
  850.   {
  851.     if ((*ptr)->cmp_offset(table->rec_buff_length))
  852.       return 1;
  853.   }
  854.   return 0;
  855. }
  856. static bool copy_blobs(Field **ptr)
  857. {
  858.   for (; *ptr ; ptr++)
  859.   {
  860.     if ((*ptr)->flags & BLOB_FLAG)
  861.       if (((Field_blob *) (*ptr))->copy())
  862. return 1; // Error
  863.   }
  864.   return 0;
  865. }
  866. static void free_blobs(Field **ptr)
  867. {
  868.   for (; *ptr ; ptr++)
  869.   {
  870.     if ((*ptr)->flags & BLOB_FLAG)
  871.       ((Field_blob *) (*ptr))->free();
  872.   }
  873. }
  874. static int
  875. remove_duplicates(JOIN *join, TABLE *entry,List<Item> &fields, Item *having)
  876. {
  877.   int error;
  878.   ulong reclength,offset;
  879.   uint field_count;
  880.   THD *thd= join->thd;
  881.   DBUG_ENTER("remove_duplicates");
  882.   entry->reginfo.lock_type=TL_WRITE;
  883.   /* Calculate how many saved fields there is in list */
  884.   field_count=0;
  885.   List_iterator<Item> it(fields);
  886.   Item *item;
  887.   while ((item=it++))
  888.   {
  889.     if (item->get_tmp_table_field() && ! item->const_item())
  890.       field_count++;
  891.   }
  892.   if (!field_count && !(join->select_options & OPTION_FOUND_ROWS)) 
  893.   {                    // only const items with no OPTION_FOUND_ROWS
  894.     join->unit->select_limit_cnt= 1; // Only send first row
  895.     DBUG_RETURN(0);
  896.   }
  897.   Field **first_field=entry->field+entry->fields - field_count;
  898.   offset= field_count ? 
  899.           entry->field[entry->fields - field_count]->offset() : 0;
  900.   reclength=entry->reclength-offset;
  901.   free_io_cache(entry); // Safety
  902.   entry->file->info(HA_STATUS_VARIABLE);
  903.   if (entry->db_type == DB_TYPE_HEAP ||
  904.       (!entry->blob_fields &&
  905.        ((ALIGN_SIZE(reclength) + HASH_OVERHEAD) * entry->file->records <
  906. thd->variables.sortbuff_size)))
  907.     error=remove_dup_with_hash_index(join->thd, entry,
  908.      field_count, first_field,
  909.      reclength, having);
  910.   else
  911.     error=remove_dup_with_compare(join->thd, entry, first_field, offset,
  912.   having);
  913.   free_blobs(first_field);
  914.   DBUG_RETURN(error);
  915. }
  916. static int remove_dup_with_compare(THD *thd, TABLE *table, Field **first_field,
  917.    ulong offset, Item *having)
  918. {
  919.   handler *file=table->file;
  920.   char *org_record,*new_record;
  921.   byte *record;
  922.   int error;
  923.   ulong reclength=table->reclength-offset;
  924.   DBUG_ENTER("remove_dup_with_compare");
  925.   org_record=(char*) (record=table->record[0])+offset;
  926.   new_record=(char*) table->record[1]+offset;
  927.   file->ha_rnd_init(1);
  928.   error=file->rnd_next(record);
  929.   for (;;)
  930.   {
  931.     if (thd->killed)
  932.     {
  933.       my_error(ER_SERVER_SHUTDOWN,MYF(0));
  934.       error=0;
  935.       goto err;
  936.     }
  937.     if (error)
  938.     {
  939.       if (error == HA_ERR_RECORD_DELETED)
  940. continue;
  941.       if (error == HA_ERR_END_OF_FILE)
  942. break;
  943.       goto err;
  944.     }
  945.     if (having && !having->val_int())
  946.     {
  947.       if ((error=file->delete_row(record)))
  948. goto err;
  949.       error=file->rnd_next(record);
  950.       continue;
  951.     }
  952.     if (copy_blobs(first_field))
  953.     {
  954.       my_error(ER_OUTOFMEMORY,MYF(0));
  955.       error=0;
  956.       goto err;
  957.     }
  958.     memcpy(new_record,org_record,reclength);
  959.     /* Read through rest of file and mark duplicated rows deleted */
  960.     bool found=0;
  961.     for (;;)
  962.     {
  963.       if ((error=file->rnd_next(record)))
  964.       {
  965. if (error == HA_ERR_RECORD_DELETED)
  966.   continue;
  967. if (error == HA_ERR_END_OF_FILE)
  968.   break;
  969. goto err;
  970.       }
  971.       if (compare_record(table, first_field) == 0)
  972.       {
  973. if ((error=file->delete_row(record)))
  974.   goto err;
  975.       }
  976.       else if (!found)
  977.       {
  978. found=1;
  979. file->position(record); // Remember position
  980.       }
  981.     }
  982.     if (!found)
  983.       break; // End of file
  984.     /* Restart search on next row */
  985.     error=file->restart_rnd_next(record,file->ref);
  986.   }
  987.   file->extra(HA_EXTRA_NO_CACHE);
  988.   DBUG_RETURN(0);
  989. err:
  990.   file->extra(HA_EXTRA_NO_CACHE);
  991.   if (error)
  992.     file->print_error(error,MYF(0));
  993.   DBUG_RETURN(1);
  994. }
  995. /*
  996.   Generate a hash index for each row to quickly find duplicate rows
  997.   Note that this will not work on tables with blobs!
  998. */
  999. static int remove_dup_with_hash_index(THD *thd, TABLE *table,
  1000.       uint field_count,
  1001.       Field **first_field,
  1002.       ulong key_length,
  1003.       Item *having)
  1004. {
  1005.   byte *key_buffer, *key_pos, *record=table->record[0];
  1006.   int error;
  1007.   handler *file= table->file;
  1008.   ulong extra_length= ALIGN_SIZE(key_length)-key_length;
  1009.   uint *field_lengths,*field_length;
  1010.   HASH hash;
  1011.   DBUG_ENTER("remove_dup_with_hash_index");
  1012.   if (!my_multi_malloc(MYF(MY_WME),
  1013.        &key_buffer,
  1014.        (uint) ((key_length + extra_length) *
  1015.        (long) file->records),
  1016.        &field_lengths,
  1017.        (uint) (field_count*sizeof(*field_lengths)),
  1018.        NullS))
  1019.     DBUG_RETURN(1);
  1020.   {
  1021.     Field **ptr;
  1022.     ulong total_length= 0;
  1023.     for (ptr= first_field, field_length=field_lengths ; *ptr ; ptr++)
  1024.     {
  1025.       uint length= (*ptr)->pack_length();
  1026.       (*field_length++)= length;
  1027.       total_length+= length;
  1028.     }
  1029.     DBUG_PRINT("info",("field_count: %u  key_length: %lu  total_length: %lu",
  1030.                        field_count, key_length, total_length));
  1031.     DBUG_ASSERT(total_length <= key_length);
  1032.     key_length= total_length;
  1033.     extra_length= ALIGN_SIZE(key_length)-key_length;
  1034.   }
  1035.   if (hash_init(&hash, &my_charset_bin, (uint) file->records, 0, 
  1036. key_length, (hash_get_key) 0, 0, 0))
  1037.   {
  1038.     my_free((char*) key_buffer,MYF(0));
  1039.     DBUG_RETURN(1);
  1040.   }
  1041.   file->ha_rnd_init(1);
  1042.   key_pos=key_buffer;
  1043.   for (;;)
  1044.   {
  1045.     byte *org_key_pos;
  1046.     if (thd->killed)
  1047.     {
  1048.       my_error(ER_SERVER_SHUTDOWN,MYF(0));
  1049.       error=0;
  1050.       goto err;
  1051.     }
  1052.     if ((error=file->rnd_next(record)))
  1053.     {
  1054.       if (error == HA_ERR_RECORD_DELETED)
  1055. continue;
  1056.       if (error == HA_ERR_END_OF_FILE)
  1057. break;
  1058.       goto err;
  1059.     }
  1060.     if (having && !having->val_int())
  1061.     {
  1062.       if ((error=file->delete_row(record)))
  1063. goto err;
  1064.       continue;
  1065.     }
  1066.     /* copy fields to key buffer */
  1067.     org_key_pos= key_pos;
  1068.     field_length=field_lengths;
  1069.     for (Field **ptr= first_field ; *ptr ; ptr++)
  1070.     {
  1071.       (*ptr)->sort_string((char*) key_pos,*field_length);
  1072.       key_pos+= *field_length++;
  1073.     }
  1074.     /* Check if it exists before */
  1075.     if (hash_search(&hash, org_key_pos, key_length))
  1076.     {
  1077.       /* Duplicated found ; Remove the row */
  1078.       if ((error=file->delete_row(record)))
  1079. goto err;
  1080.     }
  1081.     else
  1082.       (void) my_hash_insert(&hash, org_key_pos);
  1083.     key_pos+=extra_length;
  1084.   }
  1085.   my_free((char*) key_buffer,MYF(0));
  1086.   hash_free(&hash);
  1087.   file->extra(HA_EXTRA_NO_CACHE);
  1088.   (void) file->ha_rnd_end();
  1089.   DBUG_RETURN(0);
  1090. err:
  1091.   my_free((char*) key_buffer,MYF(0));
  1092.   hash_free(&hash);
  1093.   file->extra(HA_EXTRA_NO_CACHE);
  1094.   (void) file->ha_rnd_end();
  1095.   if (error)
  1096.     file->print_error(error,MYF(0));
  1097.   DBUG_RETURN(1);
  1098. }
  1099. SORT_FIELD *make_unireg_sortorder(ORDER *order, uint *length)
  1100. {
  1101.   uint count;
  1102.   SORT_FIELD *sort,*pos;
  1103.   DBUG_ENTER("make_unireg_sortorder");
  1104.   count=0;
  1105.   for (ORDER *tmp = order; tmp; tmp=tmp->next)
  1106.     count++;
  1107.   pos=sort=(SORT_FIELD*) sql_alloc(sizeof(SORT_FIELD)*(count+1));
  1108.   if (!pos)
  1109.     return 0;
  1110.   for (;order;order=order->next,pos++)
  1111.   {
  1112.     pos->field=0; pos->item=0;
  1113.     if (order->item[0]->type() == Item::FIELD_ITEM)
  1114.       pos->field= ((Item_field*) (*order->item))->field;
  1115.     else if (order->item[0]->type() == Item::SUM_FUNC_ITEM &&
  1116.      !order->item[0]->const_item())
  1117.       pos->field= ((Item_sum*) order->item[0])->get_tmp_table_field();
  1118.     else if (order->item[0]->type() == Item::COPY_STR_ITEM)
  1119.     { // Blob patch
  1120.       pos->item= ((Item_copy_string*) (*order->item))->item;
  1121.     }
  1122.     else
  1123.       pos->item= *order->item;
  1124.     pos->reverse=! order->asc;
  1125.   }
  1126.   *length=count;
  1127.   DBUG_RETURN(sort);
  1128. }
  1129. /*****************************************************************************
  1130.   Fill join cache with packed records
  1131.   Records are stored in tab->cache.buffer and last record in
  1132.   last record is stored with pointers to blobs to support very big
  1133.   records
  1134. ******************************************************************************/
  1135. static int
  1136. join_init_cache(THD *thd,JOIN_TAB *tables,uint table_count)
  1137. {
  1138.   reg1 uint i;
  1139.   uint length,blobs,size;
  1140.   CACHE_FIELD *copy,**blob_ptr;
  1141.   JOIN_CACHE  *cache;
  1142.   JOIN_TAB *join_tab;
  1143.   DBUG_ENTER("join_init_cache");
  1144.   cache= &tables[table_count].cache;
  1145.   cache->fields=blobs=0;
  1146.   join_tab=tables;
  1147.   for (i=0 ; i < table_count ; i++,join_tab++)
  1148.   {
  1149.     if (!join_tab->used_fieldlength) /* Not calced yet */
  1150.       calc_used_field_length(thd, join_tab);
  1151.     cache->fields+=join_tab->used_fields;
  1152.     blobs+=join_tab->used_blobs;
  1153.   }
  1154.   if (!(cache->field=(CACHE_FIELD*)
  1155. sql_alloc(sizeof(CACHE_FIELD)*(cache->fields+table_count*2)+(blobs+1)*
  1156.   sizeof(CACHE_FIELD*))))
  1157.   {
  1158.     my_free((gptr) cache->buff,MYF(0)); /* purecov: inspected */
  1159.     cache->buff=0; /* purecov: inspected */
  1160.     DBUG_RETURN(1); /* purecov: inspected */
  1161.   }
  1162.   copy=cache->field;
  1163.   blob_ptr=cache->blob_ptr=(CACHE_FIELD**)
  1164.     (cache->field+cache->fields+table_count*2);
  1165.   length=0;
  1166.   for (i=0 ; i < table_count ; i++)
  1167.   {
  1168.     uint null_fields=0,used_fields;
  1169.     Field **f_ptr,*field;
  1170.     for (f_ptr=tables[i].table->field,used_fields=tables[i].used_fields ;
  1171.  used_fields ;
  1172.  f_ptr++)
  1173.     {
  1174.       field= *f_ptr;
  1175.       if (field->query_id == thd->query_id)
  1176.       {
  1177. used_fields--;
  1178. length+=field->fill_cache_field(copy);
  1179. if (copy->blob_field)
  1180.   (*blob_ptr++)=copy;
  1181. if (field->maybe_null())
  1182.   null_fields++;
  1183. copy++;
  1184.       }
  1185.     }
  1186.     /* Copy null bits from table */
  1187.     if (null_fields && tables[i].table->null_fields)
  1188.     { /* must copy null bits */
  1189.       copy->str=(char*) tables[i].table->null_flags;
  1190.       copy->length=tables[i].table->null_bytes;
  1191.       copy->strip=0;
  1192.       copy->blob_field=0;
  1193.       length+=copy->length;
  1194.       copy++;
  1195.       cache->fields++;
  1196.     }
  1197.     /* If outer join table, copy null_row flag */
  1198.     if (tables[i].table->maybe_null)
  1199.     {
  1200.       copy->str= (char*) &tables[i].table->null_row;
  1201.       copy->length=sizeof(tables[i].table->null_row);
  1202.       copy->strip=0;
  1203.       copy->blob_field=0;
  1204.       length+=copy->length;
  1205.       copy++;
  1206.       cache->fields++;
  1207.     }
  1208.   }
  1209.   cache->length=length+blobs*sizeof(char*);
  1210.   cache->blobs=blobs;
  1211.   *blob_ptr=0; /* End sequentel */
  1212.   size=max(thd->variables.join_buff_size, cache->length);
  1213.   if (!(cache->buff=(uchar*) my_malloc(size,MYF(0))))
  1214.     DBUG_RETURN(1); /* Don't use cache */ /* purecov: inspected */
  1215.   cache->end=cache->buff+size;
  1216.   reset_cache_write(cache);
  1217.   DBUG_RETURN(0);
  1218. }
  1219. static ulong
  1220. used_blob_length(CACHE_FIELD **ptr)
  1221. {
  1222.   uint length,blob_length;
  1223.   for (length=0 ; *ptr ; ptr++)
  1224.   {
  1225.     (*ptr)->blob_length=blob_length=(*ptr)->blob_field->get_length();
  1226.     length+=blob_length;
  1227.     (*ptr)->blob_field->get_ptr(&(*ptr)->str);
  1228.   }
  1229.   return length;
  1230. }
  1231. static bool
  1232. store_record_in_cache(JOIN_CACHE *cache)
  1233. {
  1234.   uint length;
  1235.   uchar *pos;
  1236.   CACHE_FIELD *copy,*end_field;
  1237.   bool last_record;
  1238.   pos=cache->pos;
  1239.   end_field=cache->field+cache->fields;
  1240.   length=cache->length;
  1241.   if (cache->blobs)
  1242.     length+=used_blob_length(cache->blob_ptr);
  1243.   if ((last_record=(length+cache->length > (uint) (cache->end - pos))))
  1244.     cache->ptr_record=cache->records;
  1245.   /*
  1246.     There is room in cache. Put record there
  1247.   */
  1248.   cache->records++;
  1249.   for (copy=cache->field ; copy < end_field; copy++)
  1250.   {
  1251.     if (copy->blob_field)
  1252.     {
  1253.       if (last_record)
  1254.       {
  1255. copy->blob_field->get_image((char*) pos,copy->length+sizeof(char*), 
  1256.     copy->blob_field->charset());
  1257. pos+=copy->length+sizeof(char*);
  1258.       }
  1259.       else
  1260.       {
  1261. copy->blob_field->get_image((char*) pos,copy->length, // blob length
  1262.     copy->blob_field->charset());
  1263. memcpy(pos+copy->length,copy->str,copy->blob_length);  // Blob data
  1264. pos+=copy->length+copy->blob_length;
  1265.       }
  1266.     }
  1267.     else
  1268.     {
  1269.       if (copy->strip)
  1270.       {
  1271. char *str,*end;
  1272. for (str=copy->str,end= str+copy->length;
  1273.      end > str && end[-1] == ' ' ;
  1274.      end--) ;
  1275. length=(uint) (end-str);
  1276. memcpy(pos+2, str, length);
  1277.         int2store(pos, length);
  1278. pos+= length+2;
  1279.       }
  1280.       else
  1281.       {
  1282. memcpy(pos,copy->str,copy->length);
  1283. pos+=copy->length;
  1284.       }
  1285.     }
  1286.   }
  1287.   cache->pos=pos;
  1288.   return last_record || (uint) (cache->end -pos) < cache->length;
  1289. }
  1290. static void
  1291. reset_cache_read(JOIN_CACHE *cache)
  1292. {
  1293.   cache->record_nr=0;
  1294.   cache->pos=cache->buff;
  1295. }
  1296. static void reset_cache_write(JOIN_CACHE *cache)
  1297. {
  1298.   reset_cache_read(cache);
  1299.   cache->records= 0;
  1300.   cache->ptr_record= (uint) ~0;
  1301. }
  1302. static void
  1303. read_cached_record(JOIN_TAB *tab)
  1304. {
  1305.   uchar *pos;
  1306.   uint length;
  1307.   bool last_record;
  1308.   CACHE_FIELD *copy,*end_field;
  1309.   last_record=tab->cache.record_nr++ == tab->cache.ptr_record;
  1310.   pos=tab->cache.pos;
  1311.   for (copy=tab->cache.field,end_field=copy+tab->cache.fields ;
  1312.        copy < end_field;
  1313.        copy++)
  1314.   {
  1315.     if (copy->blob_field)
  1316.     {
  1317.       if (last_record)
  1318.       {
  1319. copy->blob_field->set_image((char*) pos,copy->length+sizeof(char*),
  1320.     copy->blob_field->charset());
  1321. pos+=copy->length+sizeof(char*);
  1322.       }
  1323.       else
  1324.       {
  1325. copy->blob_field->set_ptr((char*) pos,(char*) pos+copy->length);
  1326. pos+=copy->length+copy->blob_field->get_length();
  1327.       }
  1328.     }
  1329.     else
  1330.     {
  1331.       if (copy->strip)
  1332.       {
  1333.         length= uint2korr(pos);
  1334. memcpy(copy->str, pos+2, length);
  1335. memset(copy->str+length, ' ', copy->length-length);
  1336. pos+= 2 + length;
  1337.       }
  1338.       else
  1339.       {
  1340. memcpy(copy->str,pos,copy->length);
  1341. pos+=copy->length;
  1342.       }
  1343.     }
  1344.   }
  1345.   tab->cache.pos=pos;
  1346.   return;
  1347. }
  1348. static bool
  1349. cmp_buffer_with_ref(JOIN_TAB *tab)
  1350. {
  1351.   bool diff;
  1352.   if (!(diff=tab->ref.key_err))
  1353.   {
  1354.     memcpy(tab->ref.key_buff2, tab->ref.key_buff, tab->ref.key_length);
  1355.   }
  1356.   if ((tab->ref.key_err= cp_buffer_from_ref(tab->join->thd, &tab->ref)) || 
  1357.       diff)
  1358.     return 1;
  1359.   return memcmp(tab->ref.key_buff2, tab->ref.key_buff, tab->ref.key_length)
  1360.     != 0;
  1361. }
  1362. bool
  1363. cp_buffer_from_ref(THD *thd, TABLE_REF *ref)
  1364. {
  1365.   enum enum_check_fields save_count_cuted_fields= thd->count_cuted_fields;
  1366.   thd->count_cuted_fields= CHECK_FIELD_IGNORE;
  1367.   for (store_key **copy=ref->key_copy ; *copy ; copy++)
  1368.   {
  1369.     if ((*copy)->copy() & 1)
  1370.     {
  1371.       thd->count_cuted_fields= save_count_cuted_fields;
  1372.       return 1;                                 // Something went wrong
  1373.     }
  1374.   }
  1375.   thd->count_cuted_fields= save_count_cuted_fields;
  1376.   return 0;
  1377. }
  1378. /*****************************************************************************
  1379.   Group and order functions
  1380. *****************************************************************************/
  1381. /*
  1382.   Find order/group item in requested columns and change the item to point at
  1383.   it. If item doesn't exists, add it first in the field list
  1384.   Return 0 if ok.
  1385. */
  1386. static int
  1387. find_order_in_list(THD *thd, Item **ref_pointer_array,
  1388.    TABLE_LIST *tables,ORDER *order, List<Item> &fields,
  1389.    List<Item> &all_fields)
  1390. {
  1391.   Item *it= *order->item;
  1392.   if (it->type() == Item::INT_ITEM)
  1393.   { /* Order by position */
  1394.     uint count= (uint) it->val_int();
  1395.     if (!count || count > fields.elements)
  1396.     {
  1397.       my_printf_error(ER_BAD_FIELD_ERROR,ER(ER_BAD_FIELD_ERROR),
  1398.       MYF(0), it->full_name(), thd->where);
  1399.       return 1;
  1400.     }
  1401.     order->item= ref_pointer_array + count-1;
  1402.     order->in_field_list= 1;
  1403.     return 0;
  1404.   }
  1405.   uint counter;
  1406.   bool unaliased;
  1407.   Item **item= find_item_in_list(it, fields, &counter,
  1408.                                  REPORT_EXCEPT_NOT_FOUND, &unaliased);
  1409.   if (!item)
  1410.     return 1;
  1411.   if (item != (Item **)not_found_item)
  1412.   {
  1413.     /*
  1414.       If we have found field not by its alias in select list but by its
  1415.       original field name, we should additionaly check if we have conflict
  1416.       for this name (in case if we would perform lookup in all tables).
  1417.     */
  1418.     if (unaliased && !it->fixed && it->fix_fields(thd, tables, order->item))
  1419.       return 1;
  1420.     order->item= ref_pointer_array + counter;
  1421.     order->in_field_list=1;
  1422.     return 0;
  1423.   }
  1424.   order->in_field_list=0;
  1425.   /*
  1426.     We check it->fixed because Item_func_group_concat can put
  1427.     arguments for which fix_fields already was called.
  1428.     'it' reassigned in if condition because fix_field can change it.
  1429.   */
  1430.   thd->lex->current_select->is_item_list_lookup= 1;
  1431.   if (!it->fixed &&
  1432.       (it->fix_fields(thd, tables, order->item) ||
  1433.        (it= *order->item)->check_cols(1) ||
  1434.        thd->is_fatal_error))
  1435.   {
  1436.     thd->lex->current_select->is_item_list_lookup= 0;
  1437.     return 1; // Wrong field 
  1438.   }
  1439.   thd->lex->current_select->is_item_list_lookup= 0;
  1440.   uint el= all_fields.elements;
  1441.   all_fields.push_front(it);         // Add new field to field list
  1442.   ref_pointer_array[el]= it;
  1443.   order->item= ref_pointer_array + el;
  1444.   return 0;
  1445. }
  1446. /*
  1447.   Change order to point at item in select list. If item isn't a number
  1448.   and doesn't exits in the select list, add it the the field list.
  1449. */
  1450. int setup_order(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
  1451. List<Item> &fields, List<Item> &all_fields, ORDER *order)
  1452. {
  1453.   thd->where="order clause";
  1454.   for (; order; order=order->next)
  1455.   {
  1456.     if (find_order_in_list(thd, ref_pointer_array, tables, order, fields,
  1457.    all_fields))
  1458.       return 1;
  1459.   }
  1460.   return 0;
  1461. }
  1462. /*
  1463.   Intitialize the GROUP BY list.
  1464.   SYNOPSIS
  1465.    setup_group()
  1466.    thd Thread handler
  1467.    ref_pointer_array We store references to all fields that was not in
  1468. 'fields' here.   
  1469.    fields All fields in the select part. Any item in 'order'
  1470. that is part of these list is replaced by a pointer
  1471. to this fields.
  1472.    all_fields Total list of all unique fields used by the select.
  1473. All items in 'order' that was not part of fields will
  1474. be added first to this list.
  1475.   order The fields we should do GROUP BY on.
  1476.   hidden_group_fields Pointer to flag that is set to 1 if we added any fields
  1477. to all_fields.
  1478.   RETURN
  1479.    0  ok
  1480.    1  error (probably out of memory)
  1481. */
  1482. int
  1483. setup_group(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
  1484.     List<Item> &fields, List<Item> &all_fields, ORDER *order,
  1485.     bool *hidden_group_fields)
  1486. {
  1487.   *hidden_group_fields=0;
  1488.   if (!order)
  1489.     return 0; /* Everything is ok */
  1490.   if (thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY)
  1491.   {
  1492.     Item *item;
  1493.     List_iterator<Item> li(fields);
  1494.     while ((item=li++))
  1495.       item->marker=0; /* Marker that field is not used */
  1496.   }
  1497.   uint org_fields=all_fields.elements;
  1498.   thd->where="group statement";
  1499.   for (; order; order=order->next)
  1500.   {
  1501.     if (find_order_in_list(thd, ref_pointer_array, tables, order, fields,
  1502.    all_fields))
  1503.       return 1;
  1504.     (*order->item)->marker=1; /* Mark found */
  1505.     if ((*order->item)->with_sum_func)
  1506.     {
  1507.       my_printf_error(ER_WRONG_GROUP_FIELD, ER(ER_WRONG_GROUP_FIELD),MYF(0),
  1508.       (*order->item)->full_name());
  1509.       return 1;
  1510.     }
  1511.   }
  1512.   if (thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY)
  1513.   {
  1514.     /* Don't allow one to use fields that is not used in GROUP BY */
  1515.     Item *item;
  1516.     List_iterator<Item> li(fields);
  1517.     while ((item=li++))
  1518.     {
  1519.       if (item->type() != Item::SUM_FUNC_ITEM && !item->marker &&
  1520.   !item->const_item())
  1521.       {
  1522. my_printf_error(ER_WRONG_FIELD_WITH_GROUP,
  1523. ER(ER_WRONG_FIELD_WITH_GROUP),
  1524. MYF(0),item->full_name());
  1525. return 1;
  1526.       }
  1527.     }
  1528.   }
  1529.   if (org_fields != all_fields.elements)
  1530.     *hidden_group_fields=1; // group fields is not used
  1531.   return 0;
  1532. }
  1533. /*
  1534.   Add fields with aren't used at start of field list. Return FALSE if ok
  1535. */
  1536. static bool
  1537. setup_new_fields(THD *thd,TABLE_LIST *tables,List<Item> &fields,
  1538.  List<Item> &all_fields, ORDER *new_field)
  1539. {
  1540.   Item   **item;
  1541.   DBUG_ENTER("setup_new_fields");
  1542.   thd->set_query_id=1; // Not really needed, but...
  1543.   uint counter;
  1544.   bool not_used;
  1545.   for (; new_field ; new_field= new_field->next)
  1546.   {
  1547.     if ((item= find_item_in_list(*new_field->item, fields, &counter,
  1548.  IGNORE_ERRORS, &not_used)))
  1549.       new_field->item=item; /* Change to shared Item */
  1550.     else
  1551.     {
  1552.       thd->where="procedure list";
  1553.       if ((*new_field->item)->fix_fields(thd, tables, new_field->item))
  1554. DBUG_RETURN(1); /* purecov: inspected */
  1555.       all_fields.push_front(*new_field->item);
  1556.       new_field->item=all_fields.head_ref();
  1557.     }
  1558.   }
  1559.   DBUG_RETURN(0);
  1560. }
  1561. /*
  1562.   Create a group by that consist of all non const fields. Try to use
  1563.   the fields in the order given by 'order' to allow one to optimize
  1564.   away 'order by'.
  1565. */
  1566. static ORDER *
  1567. create_distinct_group(THD *thd, Item **ref_pointer_array,
  1568.                       ORDER *order_list, List<Item> &fields, 
  1569.       bool *all_order_by_fields_used)
  1570. {
  1571.   List_iterator<Item> li(fields);
  1572.   Item *item;
  1573.   ORDER *order,*group,**prev;
  1574.   uint index= 0;
  1575.   *all_order_by_fields_used= 1;
  1576.   while ((item=li++))
  1577.     item->marker=0; /* Marker that field is not used */
  1578.   prev= &group;  group=0;
  1579.   for (order=order_list ; order; order=order->next)
  1580.   {
  1581.     if (order->in_field_list)
  1582.     {
  1583.       ORDER *ord=(ORDER*) thd->memdup((char*) order,sizeof(ORDER));
  1584.       if (!ord)
  1585. return 0;
  1586.       *prev=ord;
  1587.       prev= &ord->next;
  1588.       (*ord->item)->marker=1;
  1589.     }
  1590.     else
  1591.       *all_order_by_fields_used= 0;
  1592.   }
  1593.   li.rewind();
  1594.   while ((item=li++))
  1595.   {
  1596.     if (!item->const_item() && !item->with_sum_func && !item->marker)
  1597.     {
  1598.       ORDER *ord=(ORDER*) thd->calloc(sizeof(ORDER));
  1599.       if (!ord)
  1600. return 0;
  1601.       /*
  1602.         We have here only field_list (not all_field_list), so we can use
  1603.         simple indexing of ref_pointer_array (order in the array and in the
  1604.         list are same)
  1605.       */
  1606.       ord->item= ref_pointer_array + index;
  1607.       ord->asc=1;
  1608.       *prev=ord;
  1609.       prev= &ord->next;
  1610.     }
  1611.     index++;
  1612.   }
  1613.   *prev=0;
  1614.   return group;
  1615. }
  1616. /*****************************************************************************
  1617.   Update join with count of the different type of fields
  1618. *****************************************************************************/
  1619. void
  1620. count_field_types(TMP_TABLE_PARAM *param, List<Item> &fields,
  1621.   bool reset_with_sum_func)
  1622. {
  1623.   List_iterator<Item> li(fields);
  1624.   Item *field;
  1625.   param->field_count=param->sum_func_count=param->func_count=
  1626.     param->hidden_field_count=0;
  1627.   param->quick_group=1;
  1628.   while ((field=li++))
  1629.   {
  1630.     Item::Type type=field->type();
  1631.     if (type == Item::FIELD_ITEM)
  1632.       param->field_count++;
  1633.     else if (type == Item::SUM_FUNC_ITEM)
  1634.     {
  1635.       if (! field->const_item())
  1636.       {
  1637. Item_sum *sum_item=(Item_sum*) field;
  1638. if (!sum_item->quick_group)
  1639.   param->quick_group=0; // UDF SUM function
  1640. param->sum_func_count++;
  1641. for (uint i=0 ; i < sum_item->arg_count ; i++)
  1642. {
  1643.   if (sum_item->args[0]->type() == Item::FIELD_ITEM)
  1644.     param->field_count++;
  1645.   else
  1646.     param->func_count++;
  1647. }
  1648.       }
  1649.     }
  1650.     else
  1651.     {
  1652.       param->func_count++;
  1653.       if (reset_with_sum_func)
  1654. field->with_sum_func=0;
  1655.     }
  1656.   }
  1657. }
  1658. /*
  1659.   Return 1 if second is a subpart of first argument
  1660.   If first parts has different direction, change it to second part
  1661.   (group is sorted like order)
  1662. */
  1663. static bool
  1664. test_if_subpart(ORDER *a,ORDER *b)
  1665. {
  1666.   for (; a && b; a=a->next,b=b->next)
  1667.   {
  1668.     if ((*a->item)->eq(*b->item,1))
  1669.       a->asc=b->asc;
  1670.     else
  1671.       return 0;
  1672.   }
  1673.   return test(!b);
  1674. }
  1675. /*
  1676.   Return table number if there is only one table in sort order
  1677.   and group and order is compatible
  1678.   else return 0;
  1679. */
  1680. static TABLE *
  1681. get_sort_by_table(ORDER *a,ORDER *b,TABLE_LIST *tables)
  1682. {
  1683.   table_map map= (table_map) 0;
  1684.   DBUG_ENTER("get_sort_by_table");
  1685.   if (!a)
  1686.     a=b; // Only one need to be given
  1687.   else if (!b)
  1688.     b=a;
  1689.   for (; a && b; a=a->next,b=b->next)
  1690.   {
  1691.     if (!(*a->item)->eq(*b->item,1))
  1692.       DBUG_RETURN(0);
  1693.     map|=a->item[0]->used_tables();
  1694.   }
  1695.   if (!map || (map & (RAND_TABLE_BIT | OUTER_REF_TABLE_BIT)))
  1696.     DBUG_RETURN(0);
  1697.   for (; !(map & tables->table->map) ; tables=tables->next) ;
  1698.   if (map != tables->table->map)
  1699.     DBUG_RETURN(0); // More than one table
  1700.   DBUG_PRINT("exit",("sort by table: %d",tables->table->tablenr));
  1701.   DBUG_RETURN(tables->table);
  1702. }
  1703. /* calc how big buffer we need for comparing group entries */
  1704. static void
  1705. calc_group_buffer(JOIN *join,ORDER *group)
  1706. {
  1707.   uint key_length=0, parts=0, null_parts=0;
  1708.   if (group)
  1709.     join->group= 1;
  1710.   for (; group ; group=group->next)
  1711.   {
  1712.     Field *field=(*group->item)->get_tmp_table_field();
  1713.     if (field)
  1714.     {
  1715.       if (field->type() == FIELD_TYPE_BLOB)
  1716. key_length+=MAX_BLOB_WIDTH; // Can't be used as a key
  1717.       else
  1718. key_length+=field->pack_length();
  1719.     }
  1720.     else if ((*group->item)->result_type() == REAL_RESULT)
  1721.       key_length+=sizeof(double);
  1722.     else if ((*group->item)->result_type() == INT_RESULT)
  1723.       key_length+=sizeof(longlong);
  1724.     else
  1725.       key_length+=(*group->item)->max_length;
  1726.     parts++;
  1727.     if ((*group->item)->maybe_null)
  1728.       null_parts++;
  1729.   }
  1730.   join->tmp_table_param.group_length=key_length+null_parts;
  1731.   join->tmp_table_param.group_parts=parts;
  1732.   join->tmp_table_param.group_null_parts=null_parts;
  1733. }
  1734. /*
  1735.   allocate group fields or take prepared (cached)
  1736.   SYNOPSIS
  1737.     make_group_fields()
  1738.     main_join - join of current select
  1739.     curr_join - current join (join of current select or temporary copy of it)
  1740.   RETURN
  1741.     0 - ok
  1742.     1 - failed
  1743. */
  1744. static bool
  1745. make_group_fields(JOIN *main_join, JOIN *curr_join)
  1746. {
  1747.   if (main_join->group_fields_cache.elements)
  1748.   {
  1749.     curr_join->group_fields= main_join->group_fields_cache;
  1750.     curr_join->sort_and_group= 1;
  1751.   }
  1752.   else
  1753.   {
  1754.     if (alloc_group_fields(curr_join, curr_join->group_list))
  1755.       return (1);
  1756.     main_join->group_fields_cache= curr_join->group_fields;
  1757.   }
  1758.   return (0);
  1759. }
  1760. /*
  1761.   Get a list of buffers for saveing last group
  1762.   Groups are saved in reverse order for easyer check loop
  1763. */
  1764. static bool
  1765. alloc_group_fields(JOIN *join,ORDER *group)
  1766. {
  1767.   if (group)
  1768.   {
  1769.     for (; group ; group=group->next)
  1770.     {
  1771.       Item_buff *tmp=new_Item_buff(join->thd, *group->item);
  1772.       if (!tmp || join->group_fields.push_front(tmp))
  1773. return TRUE;
  1774.     }
  1775.   }
  1776.   join->sort_and_group=1; /* Mark for do_select */
  1777.   return FALSE;
  1778. }
  1779. static int
  1780. test_if_group_changed(List<Item_buff> &list)
  1781. {
  1782.   DBUG_ENTER("test_if_group_changed");
  1783.   List_iterator<Item_buff> li(list);
  1784.   int idx= -1,i;
  1785.   Item_buff *buff;
  1786.   for (i=(int) list.elements-1 ; (buff=li++) ; i--)
  1787.   {
  1788.     if (buff->cmp())
  1789.       idx=i;
  1790.   }
  1791.   DBUG_PRINT("info", ("idx: %d", idx));
  1792.   DBUG_RETURN(idx);
  1793. }
  1794. /*
  1795.   Setup copy_fields to save fields at start of new group
  1796.   setup_copy_fields()
  1797.     thd - THD pointer
  1798.     param - temporary table parameters
  1799.     ref_pointer_array - array of pointers to top elements of filed list
  1800.     res_selected_fields - new list of items of select item list
  1801.     res_all_fields - new list of all items
  1802.     elements - number of elements in select item list
  1803.     all_fields - all fields list
  1804.   DESCRIPTION
  1805.     Setup copy_fields to save fields at start of new group
  1806.     Only FIELD_ITEM:s and FUNC_ITEM:s needs to be saved between groups.
  1807.     Change old item_field to use a new field with points at saved fieldvalue
  1808.     This function is only called before use of send_fields
  1809.   
  1810.   RETURN
  1811.     0 - ok
  1812.     !=0 - error
  1813. */
  1814. bool
  1815. setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param,
  1816.   Item **ref_pointer_array,
  1817.   List<Item> &res_selected_fields, List<Item> &res_all_fields,
  1818.   uint elements, List<Item> &all_fields)
  1819. {
  1820.   Item *pos;
  1821.   List_iterator_fast<Item> li(all_fields);
  1822.   Copy_field *copy= NULL;
  1823.   res_selected_fields.empty();
  1824.   res_all_fields.empty();
  1825.   List_iterator_fast<Item> itr(res_all_fields);
  1826.   List<Item> extra_funcs;
  1827.   uint i, border= all_fields.elements - elements;
  1828.   DBUG_ENTER("setup_copy_fields");
  1829.   if (param->field_count && 
  1830.       !(copy=param->copy_field= new Copy_field[param->field_count]))
  1831.     goto err2;
  1832.   param->copy_funcs.empty();
  1833.   for (i= 0; (pos= li++); i++)
  1834.   {
  1835.     if (pos->type() == Item::FIELD_ITEM)
  1836.     {
  1837.       Item_field *item;
  1838.       if (!(item= new Item_field(thd, ((Item_field*) pos))))
  1839. goto err;
  1840.       pos= item;
  1841.       if (item->field->flags & BLOB_FLAG)
  1842.       {
  1843. if (!(pos= new Item_copy_string(pos)))
  1844.   goto err;
  1845.        /*
  1846.          Item_copy_string::copy for function can call 
  1847.          Item_copy_string::val_int for blob via Item_ref.
  1848.          But if Item_copy_string::copy for blob isn't called before,
  1849.          it's value will be wrong
  1850.          so let's insert Item_copy_string for blobs in the beginning of 
  1851.          copy_funcs
  1852.          (to see full test case look at having.test, BUG #4358) 
  1853.        */
  1854. if (param->copy_funcs.push_front(pos))
  1855.   goto err;
  1856.       }
  1857.       else
  1858.       {
  1859. /* 
  1860.    set up save buffer and change result_field to point at 
  1861.    saved value
  1862. */
  1863. Field *field= item->field;
  1864. item->result_field=field->new_field(thd->mem_root,field->table);
  1865. char *tmp=(char*) sql_alloc(field->pack_length()+1);
  1866. if (!tmp)
  1867.   goto err;
  1868. copy->set(tmp, item->result_field);
  1869. item->result_field->move_field(copy->to_ptr,copy->to_null_ptr,1);
  1870. copy++;
  1871.       }
  1872.     }
  1873.     else if ((pos->type() == Item::FUNC_ITEM ||
  1874.       pos->type() == Item::SUBSELECT_ITEM ||
  1875.       pos->type() == Item::CACHE_ITEM ||
  1876.       pos->type() == Item::COND_ITEM) &&
  1877.      !pos->with_sum_func)
  1878.     { // Save for send fields
  1879.       /* TODO:
  1880.  In most cases this result will be sent to the user.
  1881.  This should be changed to use copy_int or copy_real depending
  1882.  on how the value is to be used: In some cases this may be an
  1883.  argument in a group function, like: IF(ISNULL(col),0,COUNT(*))
  1884.       */
  1885.       if (!(pos=new Item_copy_string(pos)))
  1886. goto err;
  1887.       if (i < border)                           // HAVING, ORDER and GROUP BY
  1888.       {
  1889.         if (extra_funcs.push_back(pos))
  1890.           goto err;
  1891.       }
  1892.       else if (param->copy_funcs.push_back(pos))
  1893. goto err;
  1894.     }
  1895.     res_all_fields.push_back(pos);
  1896.     ref_pointer_array[((i < border)? all_fields.elements-i-1 : i-border)]=
  1897.       pos;
  1898.   }
  1899.   param->copy_field_end= copy;
  1900.   for (i= 0; i < border; i++)
  1901.     itr++;
  1902.   itr.sublist(res_selected_fields, elements);
  1903.   /*
  1904.     Put elements from HAVING, ORDER BY and GROUP BY last to ensure that any
  1905.     reference used in these will resolve to a item that is already calculated
  1906.   */
  1907.   param->copy_funcs.concat(&extra_funcs);
  1908.   DBUG_RETURN(0);
  1909.  err:
  1910.   if (copy)
  1911.     delete [] param->copy_field;
  1912.   param->copy_field=0;
  1913. err2:
  1914.   DBUG_RETURN(TRUE);
  1915. }
  1916. /*
  1917.   Make a copy of all simple SELECT'ed items
  1918.   This is done at the start of a new group so that we can retrieve
  1919.   these later when the group changes.
  1920. */
  1921. void
  1922. copy_fields(TMP_TABLE_PARAM *param)
  1923. {
  1924.   Copy_field *ptr=param->copy_field;
  1925.   Copy_field *end=param->copy_field_end;
  1926.   for (; ptr != end; ptr++)
  1927.     (*ptr->do_copy)(ptr);
  1928.   List_iterator_fast<Item> it(param->copy_funcs);
  1929.   Item_copy_string *item;
  1930.   while ((item = (Item_copy_string*) it++))
  1931.     item->copy();
  1932. }
  1933. /*
  1934.   Make an array of pointers to sum_functions to speed up sum_func calculation
  1935.   SYNOPSIS
  1936.     alloc_func_list()
  1937.   RETURN
  1938.     0 ok
  1939.     1 Error
  1940. */
  1941. bool JOIN::alloc_func_list()
  1942. {
  1943.   uint func_count, group_parts;
  1944.   DBUG_ENTER("alloc_func_list");
  1945.   func_count= tmp_table_param.sum_func_count;
  1946.   /*
  1947.     If we are using rollup, we need a copy of the summary functions for
  1948.     each level
  1949.   */
  1950.   if (rollup.state != ROLLUP::STATE_NONE)
  1951.     func_count*= (send_group_parts+1);
  1952.   group_parts= send_group_parts;
  1953.   /*
  1954.     If distinct, reserve memory for possible
  1955.     disctinct->group_by optimization
  1956.   */
  1957.   if (select_distinct)
  1958.     group_parts+= fields_list.elements;
  1959.   /* This must use calloc() as rollup_make_fields depends on this */
  1960.   sum_funcs= (Item_sum**) thd->calloc(sizeof(Item_sum**) * (func_count+1) +
  1961.       sizeof(Item_sum***) * (group_parts+1));
  1962.   sum_funcs_end= (Item_sum***) (sum_funcs+func_count+1);
  1963.   DBUG_RETURN(sum_funcs == 0);
  1964. }
  1965. /*
  1966.   Initialize 'sum_funcs' array with all Item_sum objects
  1967.   SYNOPSIS
  1968.     make_sum_func_list()
  1969.     field_list All items
  1970.     send_fields Items in select list
  1971.     before_group_by Set to 1 if this is called before GROUP BY handling
  1972.   NOTES
  1973.     Calls ::setup() for all item_sum objects in field_list
  1974.   RETURN
  1975.     0  ok
  1976.     1  error
  1977. */
  1978. bool JOIN::make_sum_func_list(List<Item> &field_list, List<Item> &send_fields,
  1979.       bool before_group_by)
  1980. {
  1981.   List_iterator_fast<Item> it(field_list);
  1982.   Item_sum **func;
  1983.   Item *item;
  1984.   DBUG_ENTER("make_sum_func_list");
  1985.   func= sum_funcs;
  1986.   while ((item=it++))
  1987.   {
  1988.     if (item->type() == Item::SUM_FUNC_ITEM && !item->const_item())
  1989.     {
  1990.       *func++= (Item_sum*) item;
  1991.       /* let COUNT(DISTINCT) create the temporary table */
  1992.       if (((Item_sum*) item)->setup(thd))
  1993. DBUG_RETURN(TRUE);
  1994.     }
  1995.   }
  1996.   if (before_group_by && rollup.state == ROLLUP::STATE_INITED)
  1997.   {
  1998.     rollup.state= ROLLUP::STATE_READY;
  1999.     if (rollup_make_fields(field_list, send_fields, &func))
  2000.       DBUG_RETURN(TRUE); // Should never happen
  2001.   }
  2002.   else if (rollup.state == ROLLUP::STATE_NONE)
  2003.   {
  2004.     for (uint i=0 ; i <= send_group_parts ;i++)
  2005.       sum_funcs_end[i]= func;
  2006.   }
  2007.   else if (rollup.state == ROLLUP::STATE_READY)
  2008.     DBUG_RETURN(FALSE);                         // Don't put end marker
  2009.   *func=0; // End marker
  2010.   DBUG_RETURN(FALSE);
  2011. }
  2012. /*
  2013.   Change all funcs and sum_funcs to fields in tmp table, and create
  2014.   new list of all items.
  2015.   change_to_use_tmp_fields()
  2016.     thd - THD pointer
  2017.     ref_pointer_array - array of pointers to top elements of filed list
  2018.     res_selected_fields - new list of items of select item list
  2019.     res_all_fields - new list of all items
  2020.     elements - number of elements in select item list
  2021.     all_fields - all fields list
  2022.    RETURN
  2023.     0 - ok
  2024.     !=0 - error
  2025. */
  2026. static bool
  2027. change_to_use_tmp_fields(THD *thd, Item **ref_pointer_array,
  2028.  List<Item> &res_selected_fields,
  2029.  List<Item> &res_all_fields,
  2030.  uint elements, List<Item> &all_fields)
  2031. {
  2032.   List_iterator_fast<Item> it(all_fields);
  2033.   Item *item_field,*item;
  2034.   res_selected_fields.empty();
  2035.   res_all_fields.empty();
  2036.   uint i, border= all_fields.elements - elements;
  2037.   for (i= 0; (item= it++); i++)
  2038.   {
  2039.     Field *field;
  2040.     
  2041.     if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM)
  2042.       item_field= item;
  2043.     else
  2044.     {
  2045.       if (item->type() == Item::FIELD_ITEM)
  2046.       {
  2047. item_field= item->get_tmp_table_item(thd);
  2048.       }
  2049.       else if ((field= item->get_tmp_table_field()))
  2050.       {
  2051. if (item->type() == Item::SUM_FUNC_ITEM && field->table->group)
  2052.   item_field= ((Item_sum*) item)->result_item(field);
  2053. else
  2054.   item_field= (Item*) new Item_field(field);
  2055. if (!item_field)
  2056.   return TRUE; // Fatal error
  2057. item_field->name= item->name; /*lint -e613 */
  2058. #ifndef DBUG_OFF
  2059. if (_db_on_ && !item_field->name)
  2060. {
  2061.   char buff[256];
  2062.   String str(buff,sizeof(buff),&my_charset_bin);
  2063.   str.length(0);
  2064.   item->print(&str);
  2065.   item_field->name= sql_strmake(str.ptr(),str.length());
  2066. }
  2067. #endif
  2068.       }
  2069.       else
  2070. item_field= item;
  2071.     }
  2072.     res_all_fields.push_back(item_field);
  2073.     ref_pointer_array[((i < border)? all_fields.elements-i-1 : i-border)]=
  2074.       item_field;
  2075.   }
  2076.   List_iterator_fast<Item> itr(res_all_fields);
  2077.   for (i= 0; i < border; i++)
  2078.     itr++;
  2079.   itr.sublist(res_selected_fields, elements);
  2080.   return FALSE;
  2081. }
  2082. /*
  2083.   Change all sum_func refs to fields to point at fields in tmp table
  2084.   Change all funcs to be fields in tmp table
  2085.   change_refs_to_tmp_fields()
  2086.     thd - THD pointer
  2087.     ref_pointer_array - array of pointers to top elements of filed list
  2088.     res_selected_fields - new list of items of select item list
  2089.     res_all_fields - new list of all items
  2090.     elements - number of elements in select item list
  2091.     all_fields - all fields list
  2092.    RETURN
  2093.     0 ok
  2094.     1 error
  2095. */
  2096. static bool
  2097. change_refs_to_tmp_fields(THD *thd, Item **ref_pointer_array,
  2098.   List<Item> &res_selected_fields,
  2099.   List<Item> &res_all_fields, uint elements,
  2100.   List<Item> &all_fields)
  2101. {
  2102.   List_iterator_fast<Item> it(all_fields);
  2103.   Item *item, *new_item;
  2104.   res_selected_fields.empty();
  2105.   res_all_fields.empty();
  2106.   uint i, border= all_fields.elements - elements;
  2107.   for (i= 0; (item= it++); i++)
  2108.   {
  2109.     res_all_fields.push_back(new_item= item->get_tmp_table_item(thd));
  2110.     ref_pointer_array[((i < border)? all_fields.elements-i-1 : i-border)]=
  2111.       new_item;
  2112.   }
  2113.   List_iterator_fast<Item> itr(res_all_fields);
  2114.   for (i= 0; i < border; i++)
  2115.     itr++;
  2116.   itr.sublist(res_selected_fields, elements);
  2117.   return thd->is_fatal_error;
  2118. }
  2119. /******************************************************************************
  2120.   Code for calculating functions
  2121. ******************************************************************************/
  2122. static void
  2123. init_tmptable_sum_functions(Item_sum **func_ptr)
  2124. {
  2125.   Item_sum *func;
  2126.   while ((func= *(func_ptr++)))
  2127.     func->reset_field();
  2128. }
  2129. /* Update record 0 in tmp_table from record 1 */
  2130. static void
  2131. update_tmptable_sum_func(Item_sum **func_ptr,
  2132.  TABLE *tmp_table __attribute__((unused)))
  2133. {
  2134.   Item_sum *func;
  2135.   while ((func= *(func_ptr++)))
  2136.     func->update_field();
  2137. }
  2138. /* Copy result of sum functions to record in tmp_table */
  2139. static void
  2140. copy_sum_funcs(Item_sum **func_ptr, Item_sum **end_ptr)
  2141. {
  2142.   for (; func_ptr != end_ptr ; func_ptr++)
  2143.     (void) (*func_ptr)->save_in_result_field(1);
  2144.   return;
  2145. }
  2146. static bool
  2147. init_sum_functions(Item_sum **func_ptr, Item_sum **end_ptr)
  2148. {
  2149.   for (; func_ptr != end_ptr ;func_ptr++)
  2150.   {
  2151.     if ((*func_ptr)->reset())
  2152.       return 1;
  2153.   }
  2154.   /* If rollup, calculate the upper sum levels */
  2155.   for ( ; *func_ptr ; func_ptr++)
  2156.   {
  2157.     if ((*func_ptr)->add())
  2158.       return 1;
  2159.   }
  2160.   return 0;
  2161. }
  2162. static bool
  2163. update_sum_func(Item_sum **func_ptr)
  2164. {
  2165.   Item_sum *func;
  2166.   for (; (func= (Item_sum*) *func_ptr) ; func_ptr++)
  2167.     if (func->add())
  2168.       return 1;
  2169.   return 0;
  2170. }
  2171. /* Copy result of functions to record in tmp_table */
  2172. void
  2173. copy_funcs(Item **func_ptr)
  2174. {
  2175.   Item *func;
  2176.   for (; (func = *func_ptr) ; func_ptr++)
  2177.     func->save_in_result_field(1);
  2178. }
  2179. /*
  2180.   Create a condition for a const reference and add this to the
  2181.   currenct select for the table
  2182. */
  2183. static bool add_ref_to_table_cond(THD *thd, JOIN_TAB *join_tab)
  2184. {
  2185.   DBUG_ENTER("add_ref_to_table_cond");
  2186.   if (!join_tab->ref.key_parts)
  2187.     DBUG_RETURN(FALSE);
  2188.   Item_cond_and *cond=new Item_cond_and();
  2189.   TABLE *table=join_tab->table;
  2190.   int error;
  2191.   if (!cond)
  2192.     DBUG_RETURN(TRUE);
  2193.   for (uint i=0 ; i < join_tab->ref.key_parts ; i++)
  2194.   {
  2195.     Field *field=table->field[table->key_info[join_tab->ref.key].key_part[i].
  2196.       fieldnr-1];
  2197.     Item *value=join_tab->ref.items[i];
  2198.     cond->add(new Item_func_equal(new Item_field(field), value));
  2199.   }
  2200.   if (thd->is_fatal_error)
  2201.     DBUG_RETURN(TRUE);
  2202.   if (!cond->fixed)
  2203.     cond->fix_fields(thd,(TABLE_LIST *) 0, (Item**)&cond);
  2204.   if (join_tab->select)
  2205.   {
  2206.     error=(int) cond->add(join_tab->select->cond);
  2207.     join_tab->select_cond=join_tab->select->cond=cond;
  2208.   }
  2209.   else if ((join_tab->select=make_select(join_tab->table, 0, 0, cond,&error)))
  2210.     join_tab->select_cond=cond;
  2211.   DBUG_RETURN(error ? TRUE : FALSE);
  2212. }
  2213. /*
  2214.   Free joins of subselect of this select.
  2215.   free_underlaid_joins()
  2216.     thd - THD pointer
  2217.     select - pointer to st_select_lex which subselects joins we will free
  2218. */
  2219. void free_underlaid_joins(THD *thd, SELECT_LEX *select)
  2220. {
  2221.   for (SELECT_LEX_UNIT *unit= select->first_inner_unit();
  2222.        unit;
  2223.        unit= unit->next_unit())
  2224.     unit->cleanup();
  2225. }
  2226. /****************************************************************************
  2227.   ROLLUP handling
  2228. ****************************************************************************/
  2229. /*
  2230.   Replace occurences of group by fields in an expression by ref items
  2231.   SYNOPSIS
  2232.     change_group_ref()
  2233.     thd                  reference to the context
  2234.     expr                 expression to make replacement
  2235.     group_list           list of references to group by items
  2236.     changed        out:  returns 1 if item contains a replaced field item 
  2237.      
  2238.   DESCRIPTION
  2239.     The function replaces occurrences of group by fields in expr
  2240.     by ref objects for these fields unless they are under aggregate
  2241.     functions.
  2242.     The function also corrects value of the the maybe_null attribute
  2243.     for the items of all subexpressions containing group by fields.
  2244.   IMPLEMENTATION
  2245.     The function recursively traverses the tree of the expr expression,
  2246.     looks for occurrences of the group by fields that are not under
  2247.     aggregate functions and replaces them for the corresponding ref items.
  2248.   NOTES
  2249.     This substitution is needed GROUP BY queries with ROLLUP if
  2250.     SELECT list contains expressions over group by attributes.
  2251.   TODO: Some functions are not null-preserving. For those functions
  2252.     updating of the maybe_null attribute is an overkill. 
  2253.   EXAMPLES
  2254.     SELECT a+1 FROM t1 GROUP BY a WITH ROLLUP
  2255.     SELECT SUM(a)+a FROM t1 GROUP BY a WITH ROLLUP 
  2256.     
  2257.   RETURN
  2258.     0 if ok
  2259.     1   on error
  2260. */
  2261. static bool change_group_ref(THD *thd, Item_func *expr, ORDER *group_list,
  2262.                              bool *changed)
  2263. {
  2264.   if (expr->arg_count)
  2265.   {
  2266.     Item **arg,**arg_end;
  2267.     bool arg_changed= FALSE;
  2268.     for (arg= expr->arguments(),
  2269.          arg_end= expr->arguments()+expr->arg_count;
  2270.          arg != arg_end; arg++)
  2271.     {
  2272.       Item *item= *arg;
  2273.       if (item->type() == Item::FIELD_ITEM || item->type() == Item::REF_ITEM)
  2274.       {
  2275.         ORDER *group_tmp;
  2276.         for (group_tmp= group_list; group_tmp; group_tmp= group_tmp->next)
  2277.         {
  2278.           if (item->eq(*group_tmp->item,0))
  2279.           {
  2280.             Item *new_item;    
  2281.             if(!(new_item= new Item_ref(group_tmp->item, 0, item->name)))
  2282.               return 1;                                 // fatal_error is set
  2283.             thd->change_item_tree(arg, new_item);
  2284.             arg_changed= TRUE;
  2285.           }
  2286.         }
  2287.       }
  2288.       else if (item->type() == Item::FUNC_ITEM)
  2289.       {
  2290.         if (change_group_ref(thd, (Item_func *) item, group_list, &arg_changed))
  2291.           return 1;
  2292.       }
  2293.     }
  2294.     if (arg_changed)
  2295.     {
  2296.       expr->maybe_null= 1;
  2297.       *changed= TRUE;
  2298.     }
  2299.   }
  2300.   return 0;
  2301. }
  2302. /* Allocate memory needed for other rollup functions */
  2303. bool JOIN::rollup_init()
  2304. {
  2305.   uint i,j;
  2306.   Item **ref_array;
  2307.   tmp_table_param.quick_group= 0; // Can't create groups in tmp table
  2308.   rollup.state= ROLLUP::STATE_INITED;
  2309.   /*
  2310.     Create pointers to the different sum function groups
  2311.     These are updated by rollup_make_fields()
  2312.   */
  2313.   tmp_table_param.group_parts= send_group_parts;
  2314.   if (!(rollup.null_items= (Item_null_result**) thd->alloc((sizeof(Item*) +
  2315.                                                 sizeof(Item**) +
  2316.                                                 sizeof(List<Item>) +
  2317.                 ref_pointer_array_size)
  2318.                 * send_group_parts )))
  2319.     return 1;
  2320.   
  2321.   rollup.fields= (List<Item>*) (rollup.null_items + send_group_parts);
  2322.   rollup.ref_pointer_arrays= (Item***) (rollup.fields + send_group_parts);
  2323.   ref_array= (Item**) (rollup.ref_pointer_arrays+send_group_parts);
  2324.   /*
  2325.     Prepare space for field list for the different levels
  2326.     These will be filled up in rollup_make_fields()
  2327.   */
  2328.   for (i= 0 ; i < send_group_parts ; i++)
  2329.   {
  2330.     rollup.null_items[i]= new (thd->mem_root) Item_null_result();
  2331.     List<Item> *rollup_fields= &rollup.fields[i];
  2332.     rollup_fields->empty();
  2333.     rollup.ref_pointer_arrays[i]= ref_array;
  2334.     ref_array+= all_fields.elements;
  2335.   }
  2336.   for (i= 0 ; i < send_group_parts; i++)
  2337.   {
  2338.     for (j=0 ; j < fields_list.elements ; j++)
  2339.       rollup.fields[i].push_back(rollup.null_items[i]);
  2340.   }
  2341.   List_iterator_fast<Item> it(all_fields);
  2342.   Item *item;
  2343.   while ((item= it++))
  2344.   {
  2345.     ORDER *group_tmp;
  2346.     for (group_tmp= group_list; group_tmp; group_tmp= group_tmp->next)
  2347.     {
  2348.       if (*group_tmp->item == item)
  2349.         item->maybe_null= 1;
  2350.     }
  2351.     if (item->type() == Item::FUNC_ITEM)
  2352.     {
  2353.       bool changed= FALSE;
  2354.       if (change_group_ref(thd, (Item_func *) item, group_list, &changed))
  2355.         return 1;
  2356.       /*
  2357.         We have to prevent creation of a field in a temporary table for
  2358.         an expression that contains GROUP BY attributes.
  2359.         Marking the expression item as 'with_sum_func' will ensure this.
  2360.       */ 
  2361.       if (changed)
  2362.         item->with_sum_func= 1;
  2363.     }
  2364.   }
  2365.   return 0;
  2366. }
  2367.   
  2368. /*
  2369.   Fill up rollup structures with pointers to fields to use
  2370.   SYNOPSIS
  2371.     rollup_make_fields()
  2372.     fields_arg List of all fields (hidden and real ones)
  2373.     sel_fields Pointer to selected fields
  2374.     func Store here a pointer to all fields
  2375.   IMPLEMENTATION:
  2376.     Creates copies of item_sum items for each sum level
  2377.   RETURN
  2378.     0 if ok
  2379. In this case func is pointing to next not used element.
  2380.     1   on error
  2381. */
  2382. bool JOIN::rollup_make_fields(List<Item> &fields_arg, List<Item> &sel_fields,
  2383.       Item_sum ***func)
  2384. {
  2385.   List_iterator_fast<Item> it(fields_arg);
  2386.   Item *first_field= sel_fields.head();
  2387.   uint level;
  2388.   /*
  2389.     Create field lists for the different levels
  2390.     The idea here is to have a separate field list for each rollup level to
  2391.     avoid all runtime checks of which columns should be NULL.
  2392.     The list is stored in reverse order to get sum function in such an order
  2393.     in func that it makes it easy to reset them with init_sum_functions()
  2394.     Assuming:  SELECT a, b, c SUM(b) FROM t1 GROUP BY a,b WITH ROLLUP
  2395.     rollup.fields[0] will contain list where a,b,c is NULL
  2396.     rollup.fields[1] will contain list where b,c is NULL
  2397.     ...
  2398.     rollup.ref_pointer_array[#] points to fields for rollup.fields[#]
  2399.     ...
  2400.     sum_funcs_end[0] points to all sum functions
  2401.     sum_funcs_end[1] points to all sum functions, except grand totals
  2402.     ...
  2403.   */
  2404.   for (level=0 ; level < send_group_parts ; level++)
  2405.   {
  2406.     uint i;
  2407.     uint pos= send_group_parts - level -1;
  2408.     bool real_fields= 0;
  2409.     Item *item;
  2410.     List_iterator<Item> new_it(rollup.fields[pos]);
  2411.     Item **ref_array_start= rollup.ref_pointer_arrays[pos];
  2412.     ORDER *start_group;
  2413.     /* Point to first hidden field */
  2414.     Item **ref_array= ref_array_start + fields_arg.elements-1;
  2415.     /* Remember where the sum functions ends for the previous level */
  2416.     sum_funcs_end[pos+1]= *func;
  2417.     /* Find the start of the group for this level */
  2418.     for (i= 0, start_group= group_list ;
  2419.  i++ < pos ;
  2420.  start_group= start_group->next)
  2421.       ;
  2422.     it.rewind();
  2423.     while ((item= it++))
  2424.     {
  2425.       if (item == first_field)
  2426.       {
  2427. real_fields= 1; // End of hidden fields
  2428. ref_array= ref_array_start;
  2429.       }
  2430.       if (item->type() == Item::SUM_FUNC_ITEM && !item->const_item())
  2431.       {
  2432. /*
  2433.   This is a top level summary function that must be replaced with
  2434.   a sum function that is reset for this level.
  2435.   NOTE: This code creates an object which is not that nice in a
  2436.   sub select.  Fortunately it's not common to have rollup in
  2437.   sub selects.
  2438. */
  2439. item= item->copy_or_same(thd);
  2440. ((Item_sum*) item)->make_unique();
  2441. if (((Item_sum*) item)->setup(thd))
  2442.   return 1;
  2443. *(*func)= (Item_sum*) item;
  2444. (*func)++;
  2445.       }
  2446.       else 
  2447.       {
  2448. /* Check if this is something that is part of this group by */
  2449. ORDER *group_tmp;
  2450. for (group_tmp= start_group, i= pos ;
  2451.              group_tmp ; group_tmp= group_tmp->next, i++)
  2452. {
  2453.           if (*group_tmp->item == item)
  2454.   {
  2455.     /*
  2456.       This is an element that is used by the GROUP BY and should be
  2457.       set to NULL in this level
  2458.     */
  2459.             Item_null_result *null_item;
  2460.     item->maybe_null= 1; // Value will be null sometimes
  2461.             null_item= rollup.null_items[i];
  2462.             null_item->result_field= item->get_tmp_table_field();
  2463.             item= null_item;
  2464.     break;
  2465.   }
  2466. }
  2467.       }
  2468.       *ref_array= item;
  2469.       if (real_fields)
  2470.       {
  2471. (void) new_it++; // Point to next item
  2472. new_it.replace(item); // Replace previous
  2473. ref_array++;
  2474.       }
  2475.       else
  2476. ref_array--;
  2477.     }
  2478.   }
  2479.   sum_funcs_end[0]= *func; // Point to last function
  2480.   return 0;
  2481. }
  2482. /*
  2483.   Send all rollup levels higher than the current one to the client
  2484.   SYNOPSIS:
  2485.     rollup_send_data()
  2486.     idx Level we are on:
  2487. 0 = Total sum level
  2488. 1 = First group changed  (a)
  2489. 2 = Second group changed (a,b)
  2490.   SAMPLE
  2491.     SELECT a, b, c SUM(b) FROM t1 GROUP BY a,b WITH ROLLUP
  2492.   RETURN
  2493.     0 ok
  2494.     1   If send_data_failed()
  2495. */
  2496. int JOIN::rollup_send_data(uint idx)
  2497. {
  2498.   uint i;
  2499.   for (i= send_group_parts ; i-- > idx ; )
  2500.   {
  2501.     /* Get reference pointers to sum functions in place */
  2502.     memcpy((char*) ref_pointer_array,
  2503.    (char*) rollup.ref_pointer_arrays[i],
  2504.    ref_pointer_array_size);
  2505.     if ((!having || having->val_int()))
  2506.     {
  2507.       if (send_records < unit->select_limit_cnt && do_send_rows &&
  2508.   result->send_data(rollup.fields[i]))
  2509. return 1;
  2510.       send_records++;
  2511.     }
  2512.   }
  2513.   /* Restore ref_pointer_array */
  2514.   set_items_ref_array(current_ref_pointer_array);
  2515.   return 0;
  2516. }
  2517. /*
  2518.   Write all rollup levels higher than the current one to a temp table
  2519.   SYNOPSIS:
  2520.     rollup_write_data()
  2521.     idx                 Level we are on:
  2522.                         0 = Total sum level
  2523.                         1 = First group changed  (a)
  2524.                         2 = Second group changed (a,b)
  2525.     table               reference to temp table
  2526.   SAMPLE
  2527.     SELECT a, b, SUM(c) FROM t1 GROUP BY a,b WITH ROLLUP
  2528.   RETURN
  2529.     0 ok
  2530.     1   if write_data_failed()
  2531. */
  2532. int JOIN::rollup_write_data(uint idx, TABLE *table)
  2533. {
  2534.   uint i;
  2535.   for (i= send_group_parts ; i-- > idx ; )
  2536.   {
  2537.     /* Get reference pointers to sum functions in place */
  2538.     memcpy((char*) ref_pointer_array,
  2539.    (char*) rollup.ref_pointer_arrays[i],
  2540.    ref_pointer_array_size);
  2541.     if ((!having || having->val_int()))
  2542.     {
  2543.       int error;
  2544.       Item *item;
  2545.       List_iterator_fast<Item> it(rollup.fields[i]);
  2546.       while ((item= it++))
  2547.       {
  2548.         if (item->type() == Item::NULL_ITEM && item->is_result_field())
  2549.           item->save_in_result_field(1);
  2550.       }
  2551.       copy_sum_funcs(sum_funcs_end[i+1], sum_funcs_end[i]);
  2552.       if ((error= table->file->write_row(table->record[0])))
  2553.       {
  2554. if (create_myisam_from_heap(thd, table, &tmp_table_param,
  2555.       error, 0))
  2556.   return 1;      
  2557.       }
  2558.     }
  2559.   }
  2560.   /* Restore ref_pointer_array */
  2561.   set_items_ref_array(current_ref_pointer_array);
  2562.   return 0;
  2563. }
  2564. /*
  2565.   clear results if there are not rows found for group
  2566.   (end_send_group/end_write_group)
  2567.   SYNOPSYS
  2568.      JOIN::clear()
  2569. */
  2570. void JOIN::clear()
  2571. {
  2572.   clear_tables(this);
  2573.   copy_fields(&tmp_table_param);
  2574.   if (sum_funcs)
  2575.   {
  2576.     Item_sum *func, **func_ptr= sum_funcs;
  2577.     while ((func= *(func_ptr++)))
  2578.       func->clear();
  2579.   }
  2580. }
  2581. /****************************************************************************
  2582.   EXPLAIN handling
  2583.   Send a description about what how the select will be done to stdout
  2584. ****************************************************************************/
  2585. static void select_describe(JOIN *join, bool need_tmp_table, bool need_order,
  2586.     bool distinct,const char *message)
  2587. {
  2588.   List<Item> field_list;
  2589.   List<Item> item_list;
  2590.   THD *thd=join->thd;
  2591.   select_result *result=join->result;
  2592.   Item *item_null= new Item_null();
  2593.   CHARSET_INFO *cs= system_charset_info;
  2594.   DBUG_ENTER("select_describe");
  2595.   DBUG_PRINT("info", ("Select 0x%lx, type %s, message %s",
  2596.       (ulong)join->select_lex, join->select_lex->type,
  2597.       message ? message : "NULL"));
  2598.   /* Don't log this into the slow query log */
  2599.   thd->server_status&= ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
  2600.   join->unit->offset_limit_cnt= 0;
  2601.   if (message)
  2602.   {
  2603.     item_list.push_back(new Item_int((int32)
  2604.      join->select_lex->select_number));
  2605.     item_list.push_back(new Item_string(join->select_lex->type,
  2606. strlen(join->select_lex->type), cs));
  2607.     for (uint i=0 ; i < 7; i++)
  2608.       item_list.push_back(item_null);
  2609.     item_list.push_back(new Item_string(message,strlen(message),cs));
  2610.     if (result->send_data(item_list))
  2611.       join->error= 1;
  2612.   }
  2613.   else if (join->select_lex == join->unit->fake_select_lex)
  2614.   {
  2615.     /* 
  2616.       here we assume that the query will return at least two rows, so we
  2617.       show "filesort" in EXPLAIN. Of course, sometimes we'll be wrong
  2618.       and no filesort will be actually done, but executing all selects in
  2619.       the UNION to provide precise EXPLAIN information will hardly be
  2620.       appreciated :)
  2621.     */
  2622.     char table_name_buffer[NAME_LEN];
  2623.     item_list.empty();
  2624.     /* id */
  2625.     item_list.push_back(new Item_null);
  2626.     /* select_type */
  2627.     item_list.push_back(new Item_string(join->select_lex->type,
  2628. strlen(join->select_lex->type),
  2629. cs));
  2630.     /* table */
  2631.     {
  2632.       SELECT_LEX *sl= join->unit->first_select();
  2633.       uint len= 6, lastop= 0;
  2634.       memcpy(table_name_buffer, "<union", 6);
  2635.       for (; sl && len + lastop + 5 < NAME_LEN; sl= sl->next_select())
  2636.       {
  2637.         len+= lastop;
  2638.         lastop= my_snprintf(table_name_buffer + len, NAME_LEN - len,
  2639.                             "%u,", sl->select_number);
  2640.       }
  2641.       if (sl || len + lastop >= NAME_LEN)
  2642.       {
  2643.         memcpy(table_name_buffer + len, "...>", 5);
  2644.         len+= 4;
  2645.       }
  2646.       else
  2647.       {
  2648.         len+= lastop;
  2649.         table_name_buffer[len - 1]= '>';  // change ',' to '>'
  2650.       }
  2651.       item_list.push_back(new Item_string(table_name_buffer, len, cs));
  2652.     }
  2653.     /* type */
  2654.     item_list.push_back(new Item_string(join_type_str[JT_ALL],
  2655.   strlen(join_type_str[JT_ALL]),
  2656.   cs));
  2657.     /* possible_keys */
  2658.     item_list.push_back(item_null);
  2659.     /* key*/
  2660.     item_list.push_back(item_null);
  2661.     /* key_len */
  2662.     item_list.push_back(item_null);
  2663.     /* ref */
  2664.     item_list.push_back(item_null);
  2665.     /* rows */
  2666.     item_list.push_back(item_null);
  2667.     /* extra */
  2668.     if (join->unit->global_parameters->order_list.first)
  2669.       item_list.push_back(new Item_string("Using filesort",
  2670.   14, cs));
  2671.     else
  2672.       item_list.push_back(new Item_string("", 0, cs));
  2673.     if (result->send_data(item_list))
  2674.       join->error= 1;
  2675.   }
  2676.   else
  2677.   {
  2678.     table_map used_tables=0;
  2679.     for (uint i=0 ; i < join->tables ; i++)
  2680.     {
  2681.       JOIN_TAB *tab=join->join_tab+i;
  2682.       TABLE *table=tab->table;
  2683.       char buff[512],*buff_ptr=buff;
  2684.       char buff1[512], buff2[512];
  2685.       char table_name_buffer[NAME_LEN];
  2686.       String tmp1(buff1,sizeof(buff1),cs);
  2687.       String tmp2(buff2,sizeof(buff2),cs);
  2688.       tmp1.length(0);
  2689.       tmp2.length(0);
  2690.       item_list.empty();
  2691.       /* id */
  2692.       item_list.push_back(new Item_uint((uint32)
  2693.        join->select_lex->select_number));
  2694.       /* select_type */
  2695.       item_list.push_back(new Item_string(join->select_lex->type,
  2696.   strlen(join->select_lex->type),
  2697.   cs));
  2698.       if (tab->type == JT_ALL && tab->select && tab->select->quick)
  2699. tab->type= JT_RANGE;
  2700.       /* table */
  2701.       if (table->derived_select_number)
  2702.       {
  2703. /* Derived table name generation */
  2704. int len= my_snprintf(table_name_buffer, sizeof(table_name_buffer)-1,
  2705.      "<derived%u>",
  2706.      table->derived_select_number);
  2707. item_list.push_back(new Item_string(table_name_buffer, len, cs));
  2708.       }
  2709.       else
  2710. item_list.push_back(new Item_string(table->table_name,
  2711.     strlen(table->table_name),
  2712.     cs));
  2713.       /* type */
  2714.       item_list.push_back(new Item_string(join_type_str[tab->type],
  2715.   strlen(join_type_str[tab->type]),
  2716.   cs));
  2717.       uint j;
  2718.       /* possible_keys */
  2719.       if (!tab->keys.is_clear_all())
  2720.       {
  2721.         for (j=0 ; j < table->keys ; j++)
  2722.         {
  2723.           if (tab->keys.is_set(j))
  2724.           {
  2725.             if (tmp1.length())
  2726.               tmp1.append(',');
  2727.             tmp1.append(table->key_info[j].name, 
  2728. strlen(table->key_info[j].name),
  2729. system_charset_info);
  2730.           }
  2731.         }
  2732.       }
  2733.       if (tmp1.length())
  2734. item_list.push_back(new Item_string(tmp1.ptr(),tmp1.length(),cs));
  2735.       else
  2736. item_list.push_back(item_null);
  2737.       /* key key_len ref */
  2738.       if (tab->ref.key_parts)
  2739.       {
  2740. KEY *key_info=table->key_info+ tab->ref.key;
  2741. item_list.push_back(new Item_string(key_info->name,
  2742.     strlen(key_info->name),
  2743.     system_charset_info));
  2744. item_list.push_back(new Item_int((int32) tab->ref.key_length));
  2745. for (store_key **ref=tab->ref.key_copy ; *ref ; ref++)
  2746. {
  2747.   if (tmp2.length())
  2748.     tmp2.append(',');
  2749.   tmp2.append((*ref)->name(), strlen((*ref)->name()),
  2750.       system_charset_info);
  2751. }
  2752. item_list.push_back(new Item_string(tmp2.ptr(),tmp2.length(),cs));
  2753.       }
  2754.       else if (tab->type == JT_NEXT)
  2755.       {
  2756. KEY *key_info=table->key_info+ tab->index;
  2757. item_list.push_back(new Item_string(key_info->name,
  2758.     strlen(key_info->name),cs));
  2759. item_list.push_back(new Item_int((int32) key_info->key_length));
  2760. item_list.push_back(item_null);
  2761.       }
  2762.       else if (tab->select && tab->select->quick)
  2763.       {
  2764. KEY *key_info=table->key_info+ tab->select->quick->index;
  2765. item_list.push_back(new Item_string(key_info->name,
  2766.     strlen(key_info->name),cs));
  2767. item_list.push_back(new Item_int((int32) tab->select->quick->
  2768.  max_used_key_length));
  2769. item_list.push_back(item_null);
  2770.       }
  2771.       else
  2772.       {
  2773. item_list.push_back(item_null);
  2774. item_list.push_back(item_null);
  2775. item_list.push_back(item_null);
  2776.       }
  2777.       /* rows */
  2778.       item_list.push_back(new Item_int((longlong) (ulonglong)
  2779.        join->best_positions[i]. records_read,
  2780.        21));
  2781.       /* extra */
  2782.       my_bool key_read=table->key_read;
  2783.       if ((tab->type == JT_NEXT || tab->type == JT_CONST) &&
  2784.           table->used_keys.is_set(tab->index))
  2785. key_read=1;
  2786.       if (tab->info)
  2787. item_list.push_back(new Item_string(tab->info,strlen(tab->info),cs));
  2788.       else
  2789.       {
  2790. if (tab->select)
  2791. {
  2792.   if (tab->use_quick == 2)
  2793.   {
  2794.             char buf[MAX_KEY/8+1];
  2795.     sprintf(buff_ptr,"; Range checked for each record (index map: 0x%s)",
  2796.                 tab->keys.print(buf));
  2797.     buff_ptr=strend(buff_ptr);
  2798.   }
  2799.   else
  2800.     buff_ptr=strmov(buff_ptr,"; Using where");
  2801. }
  2802. if (key_read)
  2803.   buff_ptr= strmov(buff_ptr,"; Using index");
  2804. if (table->reginfo.not_exists_optimize)
  2805.   buff_ptr= strmov(buff_ptr,"; Not exists");
  2806. if (need_tmp_table)
  2807. {
  2808.   need_tmp_table=0;
  2809.   buff_ptr= strmov(buff_ptr,"; Using temporary");
  2810. }
  2811. if (need_order)
  2812. {
  2813.   need_order=0;
  2814.   buff_ptr= strmov(buff_ptr,"; Using filesort");
  2815. }
  2816. if (distinct & test_all_bits(used_tables,thd->used_tables))
  2817.   buff_ptr= strmov(buff_ptr,"; Distinct");
  2818. if (buff_ptr == buff)
  2819.   buff_ptr+= 2; // Skip inital "; "
  2820. item_list.push_back(new Item_string(buff+2,(uint) (buff_ptr - buff)-2,
  2821.     cs));
  2822.       }
  2823.       // For next iteration
  2824.       used_tables|=table->map;
  2825.       if (result->send_data(item_list))
  2826. join->error= 1;
  2827.     }
  2828.   }
  2829.   for (SELECT_LEX_UNIT *unit= join->select_lex->first_inner_unit();
  2830.        unit;
  2831.        unit= unit->next_unit())
  2832.   {
  2833.     if (mysql_explain_union(thd, unit, result))
  2834.       DBUG_VOID_RETURN;
  2835.   }
  2836.   DBUG_VOID_RETURN;
  2837. }
  2838. int mysql_explain_union(THD *thd, SELECT_LEX_UNIT *unit, select_result *result)
  2839. {
  2840.   DBUG_ENTER("mysql_explain_union");
  2841.   int res= 0;
  2842.   SELECT_LEX *first= unit->first_select();
  2843.   for (SELECT_LEX *sl= first;
  2844.        sl;
  2845.        sl= sl->next_select())
  2846.   {
  2847.     // drop UNCACHEABLE_EXPLAIN, because it is for internal usage only
  2848.     uint8 uncacheable= (sl->uncacheable & ~UNCACHEABLE_EXPLAIN);
  2849.     sl->type= (((&thd->lex->select_lex)==sl)?
  2850.        ((thd->lex->all_selects_list != sl) ? 
  2851. primary_key_name : "SIMPLE"):
  2852.        ((sl == first)?
  2853. ((sl->linkage == DERIVED_TABLE_TYPE) ?
  2854.  "DERIVED":
  2855.  ((uncacheable & UNCACHEABLE_DEPENDENT) ?
  2856.   "DEPENDENT SUBQUERY":
  2857.   (uncacheable?"UNCACHEABLE SUBQUERY":
  2858.    "SUBQUERY"))):
  2859. ((uncacheable & UNCACHEABLE_DEPENDENT) ?
  2860.  "DEPENDENT UNION":
  2861.  uncacheable?"UNCACHEABLE UNION":
  2862.  "UNION")));
  2863.     sl->options|= SELECT_DESCRIBE;
  2864.   }
  2865.   if (first->next_select())
  2866.   {
  2867.     unit->fake_select_lex->select_number= UINT_MAX; // jost for initialization
  2868.     unit->fake_select_lex->type= "UNION RESULT";
  2869.     unit->fake_select_lex->options|= SELECT_DESCRIBE;
  2870.     if (!(res= unit->prepare(thd, result, SELECT_NO_UNLOCK | SELECT_DESCRIBE,
  2871.                              "")))
  2872.       res= unit->exec();
  2873.     res|= unit->cleanup();
  2874.   }
  2875.   else
  2876.   {
  2877.     thd->lex->current_select= first;
  2878.     res= mysql_select(thd, &first->ref_pointer_array,
  2879. (TABLE_LIST*) first->table_list.first,
  2880. first->with_wild, first->item_list,
  2881. first->where,
  2882. first->order_list.elements +
  2883. first->group_list.elements,
  2884. (ORDER*) first->order_list.first,
  2885. (ORDER*) first->group_list.first,
  2886. first->having,
  2887. (ORDER*) thd->lex->proc_list.first,
  2888. first->options | thd->options | SELECT_DESCRIBE,
  2889. result, unit, first);
  2890.   }
  2891.   if (res > 0 || thd->net.report_error)
  2892.     res= -1; // mysql_explain_select do not report error
  2893.   DBUG_RETURN(res);
  2894. }
  2895. void st_select_lex::print(THD *thd, String *str)
  2896. {
  2897.   if (!thd)
  2898.     thd= current_thd;
  2899.   str->append("select ", 7);
  2900.   
  2901.   //options
  2902.   if (options & SELECT_STRAIGHT_JOIN)
  2903.     str->append("straight_join ", 14);
  2904.   if ((thd->lex->lock_option == TL_READ_HIGH_PRIORITY) &&
  2905.       (this == &thd->lex->select_lex))
  2906.     str->append("high_priority ", 14);
  2907.   if (options & SELECT_DISTINCT)
  2908.     str->append("distinct ", 9);
  2909.   if (options & SELECT_SMALL_RESULT)
  2910.     str->append("sql_small_result ", 17);
  2911.   if (options & SELECT_BIG_RESULT)
  2912.     str->append("sql_big_result ", 15);
  2913.   if (options & OPTION_BUFFER_RESULT)
  2914.     str->append("sql_buffer_result ", 18);
  2915.   if (options & OPTION_FOUND_ROWS)
  2916.     str->append("sql_calc_found_rows ", 20);
  2917.   if (!thd->lex->safe_to_cache_query)
  2918.     str->append("sql_no_cache ", 13);
  2919.   if (options & OPTION_TO_QUERY_CACHE)
  2920.     str->append("sql_cache ", 10);
  2921.   //Item List
  2922.   bool first= 1;
  2923.   List_iterator_fast<Item> it(item_list);
  2924.   Item *item;
  2925.   while ((item= it++))
  2926.   {
  2927.     if (first)
  2928.       first= 0;
  2929.     else
  2930.       str->append(',');
  2931.     item->print_item_w_name(str);
  2932.   }
  2933.   /*
  2934.     from clause
  2935.     TODO: support USING/FORCE/IGNORE index
  2936.   */
  2937.   if (table_list.elements)
  2938.   {
  2939.     str->append(" from ", 6);
  2940.     Item *next_on= 0;
  2941.     for (TABLE_LIST *table= (TABLE_LIST *) table_list.first;
  2942.  table;
  2943.  table= table->next)
  2944.     {
  2945.       if (table->derived)
  2946.       {
  2947. str->append('(');
  2948. table->derived->print(str);
  2949. str->append(") ");
  2950. str->append(table->alias);
  2951.       }
  2952.       else
  2953.       {
  2954. str->append(table->db);
  2955. str->append('.');
  2956. str->append(table->real_name);
  2957. if (my_strcasecmp(table_alias_charset, table->real_name, table->alias))
  2958. {
  2959.   str->append(' ');
  2960.   str->append(table->alias);
  2961. }
  2962.       }
  2963.       if (table->on_expr && ((table->outer_join & JOIN_TYPE_LEFT) ||
  2964.      !(table->outer_join & JOIN_TYPE_RIGHT)))
  2965. next_on= table->on_expr;
  2966.       if (next_on)
  2967.       {
  2968. str->append(" on(", 4);
  2969. next_on->print(str);
  2970. str->append(')');
  2971. next_on= 0;
  2972.       }
  2973.       TABLE_LIST *next_table;
  2974.       if ((next_table= table->next))
  2975.       {
  2976. if (table->outer_join & JOIN_TYPE_RIGHT)
  2977. {
  2978.   str->append(" right join ", 12);
  2979.   if (!(table->outer_join & JOIN_TYPE_LEFT) &&
  2980.       table->on_expr)
  2981.     next_on= table->on_expr;     
  2982. }
  2983. else if (next_table->straight)
  2984.   str->append(" straight_join ", 15);
  2985. else if (next_table->outer_join & JOIN_TYPE_LEFT)
  2986.   str->append(" left join ", 11);
  2987. else
  2988.   str->append(" join ", 6);
  2989.       }
  2990.     }
  2991.   }
  2992.   // Where
  2993.   Item *cur_where= where;
  2994.   if (join)
  2995.     cur_where= join->conds;
  2996.   if (cur_where)
  2997.   {
  2998.     str->append(" where ", 7);
  2999.     cur_where->print(str);
  3000.   }
  3001.   // group by & olap
  3002.   if (group_list.elements)
  3003.   {
  3004.     str->append(" group by ", 10);
  3005.     print_order(str, (ORDER *) group_list.first);
  3006.     switch (olap)
  3007.     {
  3008.       case CUBE_TYPE:
  3009. str->append(" with cube", 10);
  3010. break;
  3011.       case ROLLUP_TYPE:
  3012. str->append(" with rollup", 12);
  3013. break;
  3014.       default:
  3015. ;  //satisfy compiler
  3016.     }
  3017.   }
  3018.   // having
  3019.   Item *cur_having= having;
  3020.   if (join)
  3021.     cur_having= join->having;
  3022.   if (cur_having)
  3023.   {
  3024.     str->append(" having ", 8);
  3025.     cur_having->print(str);
  3026.   }
  3027.   if (order_list.elements)
  3028.   {
  3029.     str->append(" order by ", 10);
  3030.     print_order(str, (ORDER *) order_list.first);
  3031.   }
  3032.   // limit
  3033.   print_limit(thd, str);
  3034.   // PROCEDURE unsupported here
  3035. }
  3036. /*
  3037.   change select_result object of JOIN
  3038.   SYNOPSIS
  3039.     JOIN::change_result()
  3040.     res new select_result object
  3041.   RETURN
  3042.     0 - OK
  3043.     -1 - error
  3044. */
  3045. int JOIN::change_result(select_result *res)
  3046. {
  3047.   DBUG_ENTER("JOIN::change_result");
  3048.   result= res;
  3049.   if (!procedure && result->prepare(fields_list, select_lex->master_unit()))
  3050.   {
  3051.     DBUG_RETURN(-1);
  3052.   }
  3053.   DBUG_RETURN(0);
  3054. }