开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
item_sum.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：46k
源码类别：

MySQL数据库

开发平台：

Visual C++

item_sum.cpp：源码内容
  1. /* Copyright (C) 2000-2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. /* Sum functions (COUNT, MIN...) */
  20. #ifdef USE_PRAGMA_IMPLEMENTATION
  21. #pragma implementation // gcc: Class implementation
  22. #endif
  24. #include "mysql_priv.h"
  26. Item_sum::Item_sum(List<Item> &list)
  27.   :arg_count(list.elements)
  28. {
  29.   if ((args=(Item**) sql_alloc(sizeof(Item*)*arg_count)))
  30.   {
  31.     uint i=0;
  32.     List_iterator_fast<Item> li(list);
  33.     Item *item;
  35.     while ((item=li++))
  36.     {
  37.       args[i++]= item;
  38.     }
  39.   }
  40.   mark_as_sum_func();
  41.   list.empty(); // Fields are used
  42. }
  45. /*
  46.   Constructor used in processing select with temporary tebles
  47. */
  49. Item_sum::Item_sum(THD *thd, Item_sum *item):
  50.   Item_result_field(thd, item), arg_count(item->arg_count),
  51.   quick_group(item->quick_group)
  52. {
  53.   if (arg_count <= 2)
  54.     args=tmp_args;
  55.   else
  56.     if (!(args= (Item**) thd->alloc(sizeof(Item*)*arg_count)))
  57.       return;
  58.   memcpy(args, item->args, sizeof(Item*)*arg_count);
  59. }
  62. void Item_sum::mark_as_sum_func()
  63. {
  64.   current_thd->lex->current_select->with_sum_func= 1;
  65.   with_sum_func= 1;
  66. }
  69. void Item_sum::make_field(Send_field *tmp_field)
  70. {
  71.   if (args[0]->type() == Item::FIELD_ITEM && keep_field_type())
  72.   {
  73.     ((Item_field*) args[0])->field->make_field(tmp_field);
  74.     tmp_field->db_name=(char*)"";
  75.     tmp_field->org_table_name=tmp_field->table_name=(char*)"";
  76.     tmp_field->org_col_name=tmp_field->col_name=name;
  77.     if (maybe_null)
  78.       tmp_field->flags&= ~NOT_NULL_FLAG;
  79.   }
  80.   else
  81.     init_make_field(tmp_field, field_type());
  82. }
  85. void Item_sum::print(String *str)
  86. {
  87.   str->append(func_name());
  88.   str->append('(');
  89.   for (uint i=0 ; i < arg_count ; i++)
  90.   {
  91.     if (i)
  92.       str->append(',');
  93.     args[i]->print(str);
  94.   }
  95.   str->append(')');
  96. }
  98. void Item_sum::fix_num_length_and_dec()
  99. {
  100.   decimals=0;
  101.   for (uint i=0 ; i < arg_count ; i++)
  102.     set_if_bigger(decimals,args[i]->decimals);
  103.   max_length=float_length(decimals);
  104. }
  106. Item *Item_sum::get_tmp_table_item(THD *thd)
  107. {
  108.   Item_sum* sum_item= (Item_sum *) copy_or_same(thd);
  109.   if (sum_item && sum_item->result_field)    // If not a const sum func
  110.   {
  111.     Field *result_field_tmp= sum_item->result_field;
  112.     for (uint i=0 ; i < sum_item->arg_count ; i++)
  113.     {
  114.       Item *arg= sum_item->args[i];
  115.       if (!arg->const_item())
  116.       {
  117. if (arg->type() == Item::FIELD_ITEM)
  118.   ((Item_field*) arg)->field= result_field_tmp++;
  119. else
  120.   sum_item->args[i]= new Item_field(result_field_tmp++);
  121.       }
  122.     }
  123.   }
  124.   return sum_item;
  125. }
  127. bool Item_sum::walk (Item_processor processor, byte *argument)
  128. {
  129.   if (arg_count)
  130.   {
  131.     Item **arg,**arg_end;
  132.     for (arg= args, arg_end= args+arg_count; arg != arg_end; arg++)
  133.     {
  134.       if ((*arg)->walk(processor, argument))
  135. return 1;
  136.     }
  137.   }
  138.   return (this->*processor)(argument);
  139. }
  141. String *
  142. Item_sum_num::val_str(String *str)
  143. {
  144.   DBUG_ASSERT(fixed == 1);
  145.   double nr=val();
  146.   if (null_value)
  147.     return 0;
  148.   str->set(nr,decimals, &my_charset_bin);
  149.   return str;
  150. }
  153. String *
  154. Item_sum_int::val_str(String *str)
  155. {
  156.   DBUG_ASSERT(fixed == 1);
  157.   longlong nr= val_int();
  158.   if (null_value)
  159.     return 0;
  160.   if (unsigned_flag)
  161.     str->set((ulonglong) nr, &my_charset_bin);
  162.   else
  163.     str->set(nr, &my_charset_bin);
  164.   return str;
  165. }
  168. bool
  169. Item_sum_num::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
  170. {
  171.   DBUG_ASSERT(fixed == 0);
  173.   if (!thd->allow_sum_func)
  174.   {
  175.     my_error(ER_INVALID_GROUP_FUNC_USE,MYF(0));
  176.     return 1;
  177.   }
  178.   thd->allow_sum_func=0; // No included group funcs
  179.   decimals=0;
  180.   maybe_null=0;
  181.   for (uint i=0 ; i < arg_count ; i++)
  182.   {
  183.     if (args[i]->fix_fields(thd, tables, args + i) || args[i]->check_cols(1))
  184.       return 1;
  185.     if (decimals < args[i]->decimals)
  186.       decimals=args[i]->decimals;
  187.     maybe_null |= args[i]->maybe_null;
  188.   }
  189.   result_field=0;
  190.   max_length=float_length(decimals);
  191.   null_value=1;
  192.   fix_length_and_dec();
  193.   thd->allow_sum_func=1; // Allow group functions
  194.   fixed= 1;
  195.   return 0;
  196. }
  199. bool
  200. Item_sum_hybrid::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
  201. {
  202.   DBUG_ASSERT(fixed == 0);
  204.   Item *item= args[0];
  205.   if (!thd->allow_sum_func)
  206.   {
  207.     my_error(ER_INVALID_GROUP_FUNC_USE,MYF(0));
  208.     return 1;
  209.   }
  210.   thd->allow_sum_func=0; // No included group funcs
  212.   // 'item' can be changed during fix_fields
  213.   if (!item->fixed &&
  214.       item->fix_fields(thd, tables, args) ||
  215.       (item= args[0])->check_cols(1))
  216.     return 1;
  218.   hybrid_type= item->result_type();
  219.   if (hybrid_type == INT_RESULT)
  220.   {
  221.     max_length=20;
  222.   }
  223.   else if (hybrid_type == REAL_RESULT)
  224.   {
  225.     max_length=float_length(decimals);
  226.   }else
  227.   {
  228.     max_length=item->max_length;
  229.   }
  230.   decimals=item->decimals;
  231.   /* MIN/MAX can return NULL for empty set indepedent of the used column */
  232.   maybe_null= 1;
  233.   unsigned_flag=item->unsigned_flag;
  234.   collation.set(item->collation);
  235.   result_field=0;
  236.   null_value=1;
  237.   fix_length_and_dec();
  238.   thd->allow_sum_func=1; // Allow group functions
  239.   if (item->type() == Item::FIELD_ITEM)
  240.     hybrid_field_type= ((Item_field*) item)->field->type();
  241.   else
  242.     hybrid_field_type= Item::field_type();
  243.   fixed= 1;
  244.   return 0;
  245. }
  248. /***********************************************************************
  249. ** reset and add of sum_func
  250. ***********************************************************************/
  252. Item *Item_sum_sum::copy_or_same(THD* thd)
  253. {
  254.   return new (thd->mem_root) Item_sum_sum(thd, this);
  255. }
  258. void Item_sum_sum::clear()
  259. {
  260.   null_value=1; sum=0.0;
  261. }
  264. bool Item_sum_sum::add()
  265. {
  266.   sum+=args[0]->val();
  267.   if (!args[0]->null_value)
  268.     null_value= 0;
  269.   return 0;
  270. }
  273. double Item_sum_sum::val()
  274. {
  275.   DBUG_ASSERT(fixed == 1);
  276.   return sum;
  277. }
  280. Item *Item_sum_count::copy_or_same(THD* thd)
  281. {
  282.   return new (thd->mem_root) Item_sum_count(thd, this);
  283. }
  286. void Item_sum_count::clear()
  287. {
  288.   count= 0;
  289. }
  292. bool Item_sum_count::add()
  293. {
  294.   if (!args[0]->maybe_null)
  295.     count++;
  296.   else
  297.   {
  298.     (void) args[0]->val_int();
  299.     if (!args[0]->null_value)
  300.       count++;
  301.   }
  302.   return 0;
  303. }
  305. longlong Item_sum_count::val_int()
  306. {
  307.   DBUG_ASSERT(fixed == 1);
  308.   return (longlong) count;
  309. }
  312. void Item_sum_count::cleanup()
  313. {
  314.   DBUG_ENTER("Item_sum_count::cleanup");
  315.   Item_sum_int::cleanup();
  316.   used_table_cache= ~(table_map) 0;
  317.   DBUG_VOID_RETURN;
  318. }
  321. /*
  322.   Avgerage
  323. */
  325. Item *Item_sum_avg::copy_or_same(THD* thd)
  326. {
  327.   return new (thd->mem_root) Item_sum_avg(thd, this);
  328. }
  331. void Item_sum_avg::clear()
  332. {
  333.   sum=0.0; count=0;
  334. }
  337. bool Item_sum_avg::add()
  338. {
  339.   double nr=args[0]->val();
  340.   if (!args[0]->null_value)
  341.   {
  342.     sum+=nr;
  343.     count++;
  344.   }
  345.   return 0;
  346. }
  348. double Item_sum_avg::val()
  349. {
  350.   DBUG_ASSERT(fixed == 1);
  351.   if (!count)
  352.   {
  353.     null_value=1;
  354.     return 0.0;
  355.   }
  356.   null_value=0;
  357.   return sum/ulonglong2double(count);
  358. }
  361. /*
  362.   Standard deviation
  363. */
  365. double Item_sum_std::val()
  366. {
  367.   DBUG_ASSERT(fixed == 1);
  368.   double tmp= Item_sum_variance::val();
  369.   return tmp <= 0.0 ? 0.0 : sqrt(tmp);
  370. }
  372. Item *Item_sum_std::copy_or_same(THD* thd)
  373. {
  374.   return new (thd->mem_root) Item_sum_std(thd, this);
  375. }
  378. /*
  379.   Variance
  380. */
  382. Item *Item_sum_variance::copy_or_same(THD* thd)
  383. {
  384.   return new (thd->mem_root) Item_sum_variance(thd, this);
  385. }
  388. void Item_sum_variance::clear()
  389. {
  390.   sum=sum_sqr=0.0; 
  391.   count=0; 
  392. }
  394. bool Item_sum_variance::add()
  395. {
  396.   double nr=args[0]->val();
  397.   if (!args[0]->null_value)
  398.   {
  399.     sum+=nr;
  400.     sum_sqr+=nr*nr;
  401.     count++;
  402.   }
  403.   return 0;
  404. }
  406. double Item_sum_variance::val()
  407. {
  408.   DBUG_ASSERT(fixed == 1);
  409.   if (!count)
  410.   {
  411.     null_value=1;
  412.     return 0.0;
  413.   }
  414.   null_value=0;
  415.   /* Avoid problems when the precision isn't good enough */
  416.   double tmp=ulonglong2double(count);
  417.   double tmp2=(sum_sqr - sum*sum/tmp)/tmp;
  418.   return tmp2 <= 0.0 ? 0.0 : tmp2;
  419. }
  421. void Item_sum_variance::reset_field()
  422. {
  423.   double nr=args[0]->val();
  424.   char *res=result_field->ptr;
  426.   if (args[0]->null_value)
  427.     bzero(res,sizeof(double)*2+sizeof(longlong));
  428.   else
  429.   {
  430.     float8store(res,nr);
  431.     nr*=nr;
  432.     float8store(res+sizeof(double),nr);
  433.     longlong tmp=1;
  434.     int8store(res+sizeof(double)*2,tmp);
  435.   }
  436. }
  438. void Item_sum_variance::update_field()
  439. {
  440.   double nr,old_nr,old_sqr;
  441.   longlong field_count;
  442.   char *res=result_field->ptr;
  444.   float8get(old_nr, res);
  445.   float8get(old_sqr, res+sizeof(double));
  446.   field_count=sint8korr(res+sizeof(double)*2);
  448.   nr=args[0]->val();
  449.   if (!args[0]->null_value)
  450.   {
  451.     old_nr+=nr;
  452.     old_sqr+=nr*nr;
  453.     field_count++;
  454.   }
  455.   float8store(res,old_nr);
  456.   float8store(res+sizeof(double),old_sqr);
  457.   int8store(res+sizeof(double)*2,field_count);
  458. }
  460. /* min & max */
  462. void Item_sum_hybrid::clear()
  463. {
  464.   sum= 0.0;
  465.   sum_int= 0;
  466.   value.length(0);
  467.   null_value= 1;
  468. }
  470. double Item_sum_hybrid::val()
  471. {
  472.   DBUG_ASSERT(fixed == 1);
  473.   int err;
  474.   char *end_not_used;
  475.   if (null_value)
  476.     return 0.0;
  477.   switch (hybrid_type) {
  478.   case STRING_RESULT:
  479.     String *res;  res=val_str(&str_value);
  480.     return (res ? my_strntod(res->charset(), (char*) res->ptr(),res->length(),
  481.      &end_not_used, &err) : 0.0);
  482.   case INT_RESULT:
  483.     if (unsigned_flag)
  484.       return ulonglong2double(sum_int);
  485.     return (double) sum_int;
  486.   case REAL_RESULT:
  487.     return sum;
  488.   case ROW_RESULT:
  489.   default:
  490.     // This case should never be choosen
  491.     DBUG_ASSERT(0);
  492.     return 0;
  493.   }
  494.   return 0; // Keep compiler happy
  495. }
  497. longlong Item_sum_hybrid::val_int()
  498. {
  499.   DBUG_ASSERT(fixed == 1);
  500.   if (null_value)
  501.     return 0;
  502.   if (hybrid_type == INT_RESULT)
  503.     return sum_int;
  504.   return (longlong) Item_sum_hybrid::val();
  505. }
  508. String *
  509. Item_sum_hybrid::val_str(String *str)
  510. {
  511.   DBUG_ASSERT(fixed == 1);
  512.   if (null_value)
  513.     return 0;
  514.   switch (hybrid_type) {
  515.   case STRING_RESULT:
  516.     return &value;
  517.   case REAL_RESULT:
  518.     str->set(sum,decimals, &my_charset_bin);
  519.     break;
  520.   case INT_RESULT:
  521.     if (unsigned_flag)
  522.       str->set((ulonglong) sum_int, &my_charset_bin);
  523.     else
  524.       str->set((longlong) sum_int, &my_charset_bin);
  525.     break;
  526.   case ROW_RESULT:
  527.   default:
  528.     // This case should never be choosen
  529.     DBUG_ASSERT(0);
  530.     break;
  531.   }
  532.   return str; // Keep compiler happy
  533. }
  536. void Item_sum_hybrid::cleanup()
  537. {
  538.   DBUG_ENTER("Item_sum_hybrid::cleanup");
  539.   Item_sum::cleanup();
  540.   used_table_cache= ~(table_map) 0;
  542.   /*
  543.     by default it is TRUE to avoid TRUE reporting by
  544.     Item_func_not_all/Item_func_nop_all if this item was never called.
  546.     no_rows_in_result() set it to FALSE if was not results found.
  547.     If some results found it will be left unchanged.
  548.   */
  549.   was_values= TRUE;
  550.   DBUG_VOID_RETURN;
  551. }
  553. void Item_sum_hybrid::no_rows_in_result()
  554. {
  555.   was_values= FALSE;
  556.   clear();
  557. }
  560. Item *Item_sum_min::copy_or_same(THD* thd)
  561. {
  562.   return new (thd->mem_root) Item_sum_min(thd, this);
  563. }
  566. bool Item_sum_min::add()
  567. {
  568.   switch (hybrid_type) {
  569.   case STRING_RESULT:
  570.   {
  571.     String *result=args[0]->val_str(&tmp_value);
  572.     if (!args[0]->null_value &&
  573. (null_value || sortcmp(&value,result,collation.collation) > 0))
  574.     {
  575.       value.copy(*result);
  576.       null_value=0;
  577.     }
  578.   }
  579.   break;
  580.   case INT_RESULT:
  581.   {
  582.     longlong nr=args[0]->val_int();
  583.     if (!args[0]->null_value && (null_value ||
  584.  (unsigned_flag && 
  585.   (ulonglong) nr < (ulonglong) sum_int) ||
  586.  (!unsigned_flag && nr < sum_int)))
  587.     {
  588.       sum_int=nr;
  589.       null_value=0;
  590.     }
  591.   }
  592.   break;
  593.   case REAL_RESULT:
  594.   {
  595.     double nr=args[0]->val();
  596.     if (!args[0]->null_value && (null_value || nr < sum))
  597.     {
  598.       sum=nr;
  599.       null_value=0;
  600.     }
  601.   }
  602.   break;
  603.   case ROW_RESULT:
  604.   default:
  605.     // This case should never be choosen
  606.     DBUG_ASSERT(0);
  607.     break;
  608.   }
  609.   return 0;
  610. }
  613. Item *Item_sum_max::copy_or_same(THD* thd)
  614. {
  615.   return new (thd->mem_root) Item_sum_max(thd, this);
  616. }
  619. bool Item_sum_max::add()
  620. {
  621.   switch (hybrid_type) {
  622.   case STRING_RESULT:
  623.   {
  624.     String *result=args[0]->val_str(&tmp_value);
  625.     if (!args[0]->null_value &&
  626. (null_value || sortcmp(&value,result,collation.collation) < 0))
  627.     {
  628.       value.copy(*result);
  629.       null_value=0;
  630.     }
  631.   }
  632.   break;
  633.   case INT_RESULT:
  634.   {
  635.     longlong nr=args[0]->val_int();
  636.     if (!args[0]->null_value && (null_value ||
  637.  (unsigned_flag && 
  638.   (ulonglong) nr > (ulonglong) sum_int) ||
  639.  (!unsigned_flag && nr > sum_int)))
  640.     {
  641.       sum_int=nr;
  642.       null_value=0;
  643.     }
  644.   }
  645.   break;
  646.   case REAL_RESULT:
  647.   {
  648.     double nr=args[0]->val();
  649.     if (!args[0]->null_value && (null_value || nr > sum))
  650.     {
  651.       sum=nr;
  652.       null_value=0;
  653.     }
  654.   }
  655.   break;
  656.   case ROW_RESULT:
  657.   default:
  658.     // This case should never be choosen
  659.     DBUG_ASSERT(0);
  660.     break;
  661.   }
  662.   return 0;
  663. }
  666. /* bit_or and bit_and */
  668. longlong Item_sum_bit::val_int()
  669. {
  670.   DBUG_ASSERT(fixed == 1);
  671.   return (longlong) bits;
  672. }
  675. void Item_sum_bit::clear()
  676. {
  677.   bits= reset_bits;
  678. }
  680. Item *Item_sum_or::copy_or_same(THD* thd)
  681. {
  682.   return new (thd->mem_root) Item_sum_or(thd, this);
  683. }
  686. bool Item_sum_or::add()
  687. {
  688.   ulonglong value= (ulonglong) args[0]->val_int();
  689.   if (!args[0]->null_value)
  690.     bits|=value;
  691.   return 0;
  692. }
  694. Item *Item_sum_xor::copy_or_same(THD* thd)
  695. {
  696.   return new (thd->mem_root) Item_sum_xor(thd, this);
  697. }
  700. bool Item_sum_xor::add()
  701. {
  702.   ulonglong value= (ulonglong) args[0]->val_int();
  703.   if (!args[0]->null_value)
  704.     bits^=value;
  705.   return 0;
  706. }
  708. Item *Item_sum_and::copy_or_same(THD* thd)
  709. {
  710.   return new (thd->mem_root) Item_sum_and(thd, this);
  711. }
  714. bool Item_sum_and::add()
  715. {
  716.   ulonglong value= (ulonglong) args[0]->val_int();
  717.   if (!args[0]->null_value)
  718.     bits&=value;
  719.   return 0;
  720. }
  722. /************************************************************************
  723. ** reset result of a Item_sum with is saved in a tmp_table
  724. *************************************************************************/
  726. void Item_sum_num::reset_field()
  727. {
  728.   double nr=args[0]->val();
  729.   char *res=result_field->ptr;
  731.   if (maybe_null)
  732.   {
  733.     if (args[0]->null_value)
  734.     {
  735.       nr=0.0;
  736.       result_field->set_null();
  737.     }
  738.     else
  739.       result_field->set_notnull();
  740.   }
  741.   float8store(res,nr);
  742. }
  745. void Item_sum_hybrid::reset_field()
  746. {
  747.   if (hybrid_type == STRING_RESULT)
  748.   {
  749.     char buff[MAX_FIELD_WIDTH];
  750.     String tmp(buff,sizeof(buff),result_field->charset()),*res;
  752.     res=args[0]->val_str(&tmp);
  753.     if (args[0]->null_value)
  754.     {
  755.       result_field->set_null();
  756.       result_field->reset();
  757.     }
  758.     else
  759.     {
  760.       result_field->set_notnull();
  761.       result_field->store(res->ptr(),res->length(),tmp.charset());
  762.     }
  763.   }
  764.   else if (hybrid_type == INT_RESULT)
  765.   {
  766.     longlong nr=args[0]->val_int();
  768.     if (maybe_null)
  769.     {
  770.       if (args[0]->null_value)
  771.       {
  772. nr=0;
  773. result_field->set_null();
  774.       }
  775.       else
  776. result_field->set_notnull();
  777.     }
  778.     result_field->store(nr);
  779.   }
  780.   else // REAL_RESULT
  781.   {
  782.     double nr=args[0]->val();
  784.     if (maybe_null)
  785.     {
  786.       if (args[0]->null_value)
  787.       {
  788. nr=0.0;
  789. result_field->set_null();
  790.       }
  791.       else
  792. result_field->set_notnull();
  793.     }
  794.     result_field->store(nr);
  795.   }
  796. }
  799. void Item_sum_sum::reset_field()
  800. {
  801.   double nr=args[0]->val(); // Nulls also return 0
  802.   float8store(result_field->ptr,nr);
  803.   if (args[0]->null_value)
  804.     result_field->set_null();
  805.   else
  806.     result_field->set_notnull();
  807. }
  810. void Item_sum_count::reset_field()
  811. {
  812.   char *res=result_field->ptr;
  813.   longlong nr=0;
  815.   if (!args[0]->maybe_null)
  816.     nr=1;
  817.   else
  818.   {
  819.     (void) args[0]->val_int();
  820.     if (!args[0]->null_value)
  821.       nr=1;
  822.   }
  823.   int8store(res,nr);
  824. }
  827. void Item_sum_avg::reset_field()
  828. {
  829.   double nr=args[0]->val();
  830.   char *res=result_field->ptr;
  832.   if (args[0]->null_value)
  833.     bzero(res,sizeof(double)+sizeof(longlong));
  834.   else
  835.   {
  836.     float8store(res,nr);
  837.     res+=sizeof(double);
  838.     longlong tmp=1;
  839.     int8store(res,tmp);
  840.   }
  841. }
  843. void Item_sum_bit::reset_field()
  844. {
  845.   reset();
  846.   int8store(result_field->ptr, bits);
  847. }
  849. void Item_sum_bit::update_field()
  850. {
  851.   char *res=result_field->ptr;
  852.   bits= uint8korr(res);
  853.   add();
  854.   int8store(res, bits);
  855. }
  857. /*
  858. ** calc next value and merge it with field_value
  859. */
  861. void Item_sum_sum::update_field()
  862. {
  863.   double old_nr,nr;
  864.   char *res=result_field->ptr;
  866.   float8get(old_nr,res);
  867.   nr=args[0]->val();
  868.   if (!args[0]->null_value)
  869.   {
  870.     old_nr+=nr;
  871.     result_field->set_notnull();
  872.   }
  873.   float8store(res,old_nr);
  874. }
  877. void Item_sum_count::update_field()
  878. {
  879.   longlong nr;
  880.   char *res=result_field->ptr;
  882.   nr=sint8korr(res);
  883.   if (!args[0]->maybe_null)
  884.     nr++;
  885.   else
  886.   {
  887.     (void) args[0]->val_int();
  888.     if (!args[0]->null_value)
  889.       nr++;
  890.   }
  891.   int8store(res,nr);
  892. }
  895. void Item_sum_avg::update_field()
  896. {
  897.   double nr,old_nr;
  898.   longlong field_count;
  899.   char *res=result_field->ptr;
  901.   float8get(old_nr,res);
  902.   field_count=sint8korr(res+sizeof(double));
  904.   nr=args[0]->val();
  905.   if (!args[0]->null_value)
  906.   {
  907.     old_nr+=nr;
  908.     field_count++;
  909.   }
  910.   float8store(res,old_nr);
  911.   res+=sizeof(double);
  912.   int8store(res,field_count);
  913. }
  915. void Item_sum_hybrid::update_field()
  916. {
  917.   if (hybrid_type == STRING_RESULT)
  918.     min_max_update_str_field();
  919.   else if (hybrid_type == INT_RESULT)
  920.     min_max_update_int_field();
  921.   else
  922.     min_max_update_real_field();
  923. }
  926. void
  927. Item_sum_hybrid::min_max_update_str_field()
  928. {
  929.   String *res_str=args[0]->val_str(&value);
  931.   if (!args[0]->null_value)
  932.   {
  933.     res_str->strip_sp();
  934.     result_field->val_str(&tmp_value);
  936.     if (result_field->is_null() ||
  937. (cmp_sign * sortcmp(res_str,&tmp_value,collation.collation)) < 0)
  938.       result_field->store(res_str->ptr(),res_str->length(),res_str->charset());
  939.     result_field->set_notnull();
  940.   }
  941. }
  944. void
  945. Item_sum_hybrid::min_max_update_real_field()
  946. {
  947.   double nr,old_nr;
  949.   old_nr=result_field->val_real();
  950.   nr=args[0]->val();
  951.   if (!args[0]->null_value)
  952.   {
  953.     if (result_field->is_null(0) ||
  954. (cmp_sign > 0 ? old_nr > nr : old_nr < nr))
  955.       old_nr=nr;
  956.     result_field->set_notnull();
  957.   }
  958.   else if (result_field->is_null(0))
  959.     result_field->set_null();
  960.   result_field->store(old_nr);
  961. }
  964. void
  965. Item_sum_hybrid::min_max_update_int_field()
  966. {
  967.   longlong nr,old_nr;
  969.   old_nr=result_field->val_int();
  970.   nr=args[0]->val_int();
  971.   if (!args[0]->null_value)
  972.   {
  973.     if (result_field->is_null(0))
  974.       old_nr=nr;
  975.     else
  976.     {
  977.       bool res=(unsigned_flag ?
  978. (ulonglong) old_nr > (ulonglong) nr :
  979. old_nr > nr);
  980.       /* (cmp_sign > 0 && res) || (!(cmp_sign > 0) && !res) */
  981.       if ((cmp_sign > 0) ^ (!res))
  982. old_nr=nr;
  983.     }
  984.     result_field->set_notnull();
  985.   }
  986.   else if (result_field->is_null(0))
  987.     result_field->set_null();
  988.   result_field->store(old_nr);
  989. }
  992. Item_avg_field::Item_avg_field(Item_sum_avg *item)
  993. {
  994.   name=item->name;
  995.   decimals=item->decimals;
  996.   max_length=item->max_length;
  997.   field=item->result_field;
  998.   maybe_null=1;
  999. }
  1002. double Item_avg_field::val()
  1003. {
  1004.   // fix_fields() never calls for this Item
  1005.   double nr;
  1006.   longlong count;
  1007.   float8get(nr,field->ptr);
  1008.   char *res=(field->ptr+sizeof(double));
  1009.   count=sint8korr(res);
  1011.   if (!count)
  1012.   {
  1013.     null_value=1;
  1014.     return 0.0;
  1015.   }
  1016.   null_value=0;
  1017.   return nr/(double) count;
  1018. }
  1020. String *Item_avg_field::val_str(String *str)
  1021. {
  1022.   // fix_fields() never calls for this Item
  1023.   double nr=Item_avg_field::val();
  1024.   if (null_value)
  1025.     return 0;
  1026.   str->set(nr,decimals, &my_charset_bin);
  1027.   return str;
  1028. }
  1030. Item_std_field::Item_std_field(Item_sum_std *item)
  1031.   : Item_variance_field(item)
  1032. {
  1033. }
  1035. double Item_std_field::val()
  1036. {
  1037.   // fix_fields() never calls for this Item
  1038.   double tmp= Item_variance_field::val();
  1039.   return tmp <= 0.0 ? 0.0 : sqrt(tmp);
  1040. }
  1042. Item_variance_field::Item_variance_field(Item_sum_variance *item)
  1043. {
  1044.   name=item->name;
  1045.   decimals=item->decimals;
  1046.   max_length=item->max_length;
  1047.   field=item->result_field;
  1048.   maybe_null=1;
  1049. }
  1051. double Item_variance_field::val()
  1052. {
  1053.   // fix_fields() never calls for this Item
  1054.   double sum,sum_sqr;
  1055.   longlong count;
  1056.   float8get(sum,field->ptr);
  1057.   float8get(sum_sqr,(field->ptr+sizeof(double)));
  1058.   count=sint8korr(field->ptr+sizeof(double)*2);
  1060.   if (!count)
  1061.   {
  1062.     null_value=1;
  1063.     return 0.0;
  1064.   }
  1065.   null_value=0;
  1066.   double tmp= (double) count;
  1067.   double tmp2=(sum_sqr - sum*sum/tmp)/tmp;
  1068.   return tmp2 <= 0.0 ? 0.0 : tmp2;
  1069. }
  1071. String *Item_variance_field::val_str(String *str)
  1072. {
  1073.   // fix_fields() never calls for this Item
  1074.   double nr=val();
  1075.   if (null_value)
  1076.     return 0;
  1077.   str->set(nr,decimals, &my_charset_bin);
  1078.   return str;
  1079. }
  1081. /****************************************************************************
  1082. ** COUNT(DISTINCT ...)
  1083. ****************************************************************************/
  1085. #include "sql_select.h"
  1087. int simple_raw_key_cmp(void* arg, byte* key1, byte* key2)
  1088. {
  1089.   return memcmp(key1, key2, *(uint*) arg);
  1090. }
  1092. int simple_str_key_cmp(void* arg, byte* key1, byte* key2)
  1093. {
  1094.   Item_sum_count_distinct* item = (Item_sum_count_distinct*)arg;
  1095.   CHARSET_INFO *cs=item->key_charset;
  1096.   uint len=item->key_length;
  1097.   return cs->coll->strnncollsp(cs, 
  1098.        (const uchar*) key1, len, 
  1099.        (const uchar*) key2, len);
  1100. }
  1102. /*
  1103.   Did not make this one static - at least gcc gets confused when
  1104.   I try to declare a static function as a friend. If you can figure
  1105.   out the syntax to make a static function a friend, make this one
  1106.   static
  1107. */
  1109. int composite_key_cmp(void* arg, byte* key1, byte* key2)
  1110. {
  1111.   Item_sum_count_distinct* item = (Item_sum_count_distinct*)arg;
  1112.   Field **field    = item->table->field;
  1113.   Field **field_end= field + item->table->fields;
  1114.   uint32 *lengths=item->field_lengths;
  1115.   for (; field < field_end; ++field)
  1116.   {
  1117.     Field* f = *field;
  1118.     int len = *lengths++;
  1119.     int res = f->key_cmp(key1, key2);
  1120.     if (res)
  1121.       return res;
  1122.     key1 += len;
  1123.     key2 += len;
  1124.   }
  1125.   return 0;
  1126. }
  1128. /*
  1129.   helper function for walking the tree when we dump it to MyISAM -
  1130.   tree_walk will call it for each leaf
  1131. */
  1133. int dump_leaf(byte* key, uint32 count __attribute__((unused)),
  1134.      Item_sum_count_distinct* item)
  1135. {
  1136.   byte* buf = item->table->record[0];
  1137.   int error;
  1138.   /*
  1139.     The first item->rec_offset bytes are taken care of with
  1140.     restore_record(table,default_values) in setup()
  1141.   */
  1142.   memcpy(buf + item->rec_offset, key, item->tree->size_of_element);
  1143.   if ((error = item->table->file->write_row(buf)))
  1144.   {
  1145.     if (error != HA_ERR_FOUND_DUPP_KEY &&
  1146. error != HA_ERR_FOUND_DUPP_UNIQUE)
  1147.       return 1;
  1148.   }
  1149.   return 0;
  1150. }
  1153. void Item_sum_count_distinct::cleanup()
  1154. {
  1155.   DBUG_ENTER("Item_sum_count_distinct::cleanup");
  1156.   Item_sum_int::cleanup();
  1157.   /*
  1158.     Free table and tree if they belong to this item (if item have not pointer
  1159.     to original item from which was made copy => it own its objects )
  1160.   */
  1161.   if (!original)
  1162.   {
  1163.     if (table)
  1164.     {
  1165.       free_tmp_table(current_thd, table);
  1166.       table= 0;
  1167.     }
  1168.     delete tmp_table_param;
  1169.     tmp_table_param= 0;
  1170.     if (use_tree)
  1171.     {
  1172.       delete_tree(tree);
  1173.       use_tree= 0;
  1174.     }
  1175.   }
  1176.   DBUG_VOID_RETURN;
  1177. }
  1180. /* This is used by rollup to create a separate usable copy of the function */
  1182. void Item_sum_count_distinct::make_unique()
  1183. {
  1184.   table=0;
  1185.   original= 0;
  1186.   use_tree= 0; // to prevent delete_tree call on uninitialized tree
  1187.   tree= &tree_base;
  1188. }
  1191. bool Item_sum_count_distinct::setup(THD *thd)
  1192. {
  1193.   List<Item> list;
  1194.   SELECT_LEX *select_lex= thd->lex->current_select;
  1195.   if (select_lex->linkage == GLOBAL_OPTIONS_TYPE)
  1196.     return 1;
  1197.     
  1198.   if (!(tmp_table_param= new TMP_TABLE_PARAM))
  1199.     return 1;
  1201.   /* Create a table with an unique key over all parameters */
  1202.   for (uint i=0; i < arg_count ; i++)
  1203.   {
  1204.     Item *item=args[i];
  1205.     if (list.push_back(item))
  1206.       return 1; // End of memory
  1207.     if (item->const_item())
  1208.     {
  1209.       (void) item->val_int();
  1210.       if (item->null_value)
  1211. always_null=1;
  1212.     }
  1213.   }
  1214.   if (always_null)
  1215.     return 0;
  1216.   count_field_types(tmp_table_param,list,0);
  1217.   if (table)
  1218.   {
  1219.     free_tmp_table(thd, table);
  1220.     tmp_table_param->cleanup();
  1221.   }
  1222.   if (!(table= create_tmp_table(thd, tmp_table_param, list, (ORDER*) 0, 1,
  1223. 0,
  1224. select_lex->options | thd->options,
  1225. HA_POS_ERROR, (char*)"")))
  1226.     return 1;
  1227.   table->file->extra(HA_EXTRA_NO_ROWS); // Don't update rows
  1228.   table->no_rows=1;
  1231.   // no blobs, otherwise it would be MyISAM
  1232.   if (table->db_type == DB_TYPE_HEAP)
  1233.   {
  1234.     qsort_cmp2 compare_key;
  1235.     void* cmp_arg;
  1237.     // to make things easier for dump_leaf if we ever have to dump to MyISAM
  1238.     restore_record(table,default_values);
  1240.     if (table->fields == 1)
  1241.     {
  1242.       /*
  1243. If we have only one field, which is the most common use of
  1244. count(distinct), it is much faster to use a simpler key
  1245. compare method that can take advantage of not having to worry
  1246. about other fields
  1247.       */
  1248.       Field* field = table->field[0];
  1249.       switch(field->type())
  1250.       {
  1251.       case FIELD_TYPE_STRING:
  1252.       case FIELD_TYPE_VAR_STRING:
  1253. if (field->binary())
  1254. {
  1255.   compare_key = (qsort_cmp2)simple_raw_key_cmp;
  1256.   cmp_arg = (void*) &key_length;
  1257. }
  1258. else
  1259. {
  1260.   /*
  1261.     If we have a string, we must take care of charsets and case
  1262.     sensitivity
  1263.   */
  1264.   compare_key = (qsort_cmp2)simple_str_key_cmp;
  1265.   cmp_arg = (void*) this;
  1266. }
  1267. break;
  1268.       default:
  1269. /*
  1270.   Since at this point we cannot have blobs anything else can
  1271.   be compared with memcmp
  1272. */
  1273. compare_key = (qsort_cmp2)simple_raw_key_cmp;
  1274. cmp_arg = (void*) &key_length;
  1275. break;
  1276.       }
  1277.       key_charset = field->charset();
  1278.       key_length  = field->pack_length();
  1279.       rec_offset  = 1;
  1280.     }
  1281.     else // too bad, cannot cheat - there is more than one field
  1282.     {
  1283.       bool all_binary = 1;
  1284.       Field** field, **field_end;
  1285.       field_end = (field = table->field) + table->fields;
  1286.       uint32 *lengths;
  1287.       if (!(field_lengths= 
  1288.     (uint32*) thd->alloc(sizeof(uint32) * table->fields)))
  1289. return 1;
  1291.       for (key_length = 0, lengths=field_lengths; field < field_end; ++field)
  1292.       {
  1293. uint32 length= (*field)->pack_length();
  1294. key_length += length;
  1295. *lengths++ = length;
  1296. if (!(*field)->binary())
  1297.   all_binary = 0; // Can't break loop here
  1298.       }
  1299.       rec_offset = table->reclength - key_length;
  1300.       if (all_binary)
  1301.       {
  1302. compare_key = (qsort_cmp2)simple_raw_key_cmp;
  1303. cmp_arg = (void*) &key_length;
  1304.       }
  1305.       else
  1306.       {
  1307. compare_key = (qsort_cmp2) composite_key_cmp ;
  1308. cmp_arg = (void*) this;
  1309.       }
  1310.     }
  1312.     if (use_tree)
  1313.       delete_tree(tree);
  1314.     init_tree(tree, min(thd->variables.max_heap_table_size,
  1315. thd->variables.sortbuff_size/16), 0,
  1316.       key_length, compare_key, 0, NULL, cmp_arg);
  1317.     use_tree = 1;
  1319.     /*
  1320.       The only time key_length could be 0 is if someone does
  1321.       count(distinct) on a char(0) field - stupid thing to do,
  1322.       but this has to be handled - otherwise someone can crash
  1323.       the server with a DoS attack
  1324.     */
  1325.     max_elements_in_tree = ((key_length) ? 
  1326.     thd->variables.max_heap_table_size/key_length : 1);
  1328.   }
  1329.   if (original)
  1330.   {
  1331.     original->table= table;
  1332.     original->use_tree= use_tree;
  1333.   }
  1334.   return 0;
  1335. }
  1338. int Item_sum_count_distinct::tree_to_myisam()
  1339. {
  1340.   if (create_myisam_from_heap(current_thd, table, tmp_table_param,
  1341.       HA_ERR_RECORD_FILE_FULL, 1) ||
  1342.       tree_walk(tree, (tree_walk_action)&dump_leaf, (void*)this,
  1343. left_root_right))
  1344.     return 1;
  1345.   delete_tree(tree);
  1346.   use_tree = 0;
  1347.   return 0;
  1348. }
  1351. Item *Item_sum_count_distinct::copy_or_same(THD* thd) 
  1352. {
  1353.   return new (thd->mem_root) Item_sum_count_distinct(thd, this);
  1354. }
  1357. void Item_sum_count_distinct::clear()
  1358. {
  1359.   if (use_tree)
  1360.     reset_tree(tree);
  1361.   else if (table)
  1362.   {
  1363.     table->file->extra(HA_EXTRA_NO_CACHE);
  1364.     table->file->delete_all_rows();
  1365.     table->file->extra(HA_EXTRA_WRITE_CACHE);
  1366.   }
  1367. }
  1369. bool Item_sum_count_distinct::add()
  1370. {
  1371.   int error;
  1372.   if (always_null)
  1373.     return 0;
  1374.   copy_fields(tmp_table_param);
  1375.   copy_funcs(tmp_table_param->items_to_copy);
  1377.   for (Field **field=table->field ; *field ; field++)
  1378.     if ((*field)->is_real_null(0))
  1379.       return 0; // Don't count NULL
  1381.   if (use_tree)
  1382.   {
  1383.     /*
  1384.       If the tree got too big, convert to MyISAM, otherwise insert into the
  1385.       tree.
  1386.     */
  1387.     if (tree->elements_in_tree > max_elements_in_tree)
  1388.     {
  1389.       if (tree_to_myisam())
  1390. return 1;
  1391.     }
  1392.     else if (!tree_insert(tree, table->record[0] + rec_offset, 0,
  1393.   tree->custom_arg))
  1394.       return 1;
  1395.   }
  1396.   else if ((error=table->file->write_row(table->record[0])))
  1397.   {
  1398.     if (error != HA_ERR_FOUND_DUPP_KEY &&
  1399. error != HA_ERR_FOUND_DUPP_UNIQUE)
  1400.     {
  1401.       if (create_myisam_from_heap(current_thd, table, tmp_table_param, error,
  1402.   1))
  1403. return 1; // Not a table_is_full error
  1404.     }
  1405.   }
  1406.   return 0;
  1407. }
  1410. longlong Item_sum_count_distinct::val_int()
  1411. {
  1412.   DBUG_ASSERT(fixed == 1);
  1413.   if (!table) // Empty query
  1414.     return LL(0);
  1415.   if (use_tree)
  1416.     return tree->elements_in_tree;
  1417.   table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
  1418.   return table->file->records;
  1419. }
  1422. void Item_sum_count_distinct::print(String *str)
  1423. {
  1424.   str->append("count(distinct ", 15);
  1425.   args[0]->print(str);
  1426.   str->append(')');
  1427. }
  1429. /****************************************************************************
  1430. ** Functions to handle dynamic loadable aggregates
  1431. ** Original source by: Alexis Mikhailov <root@medinf.chuvashia.su>
  1432. ** Adapted for UDAs by: Andreas F. Bobak <bobak@relog.ch>.
  1433. ** Rewritten by: Monty.
  1434. ****************************************************************************/
  1436. #ifdef HAVE_DLOPEN
  1438. void Item_udf_sum::clear()
  1439. {
  1440.   DBUG_ENTER("Item_udf_sum::clear");
  1441.   udf.clear();
  1442.   DBUG_VOID_RETURN;
  1443. }
  1445. bool Item_udf_sum::add()
  1446. {
  1447.   DBUG_ENTER("Item_udf_sum::add");
  1448.   udf.add(&null_value);
  1449.   DBUG_RETURN(0);
  1450. }
  1452. void Item_udf_sum::cleanup()
  1453. {
  1454.   /*
  1455.     udf_handler::cleanup() nicely handles case when we have not
  1456.     original item but one created by copy_or_same() method.
  1457.   */
  1458.   udf.cleanup();
  1459.   Item_sum::cleanup();
  1460. }
  1463. Item *Item_sum_udf_float::copy_or_same(THD* thd)
  1464. {
  1465.   return new (thd->mem_root) Item_sum_udf_float(thd, this);
  1466. }
  1468. double Item_sum_udf_float::val()
  1469. {
  1470.   DBUG_ASSERT(fixed == 1);
  1471.   DBUG_ENTER("Item_sum_udf_float::val");
  1472.   DBUG_PRINT("info",("result_type: %d  arg_count: %d",
  1473.      args[0]->result_type(), arg_count));
  1474.   DBUG_RETURN(udf.val(&null_value));
  1475. }
  1477. String *Item_sum_udf_float::val_str(String *str)
  1478. {
  1479.   DBUG_ASSERT(fixed == 1);
  1480.   double nr=val();
  1481.   if (null_value)
  1482.     return 0; /* purecov: inspected */
  1483.   str->set(nr,decimals, &my_charset_bin);
  1484.   return str;
  1485. }
  1488. Item *Item_sum_udf_int::copy_or_same(THD* thd)
  1489. {
  1490.   return new (thd->mem_root) Item_sum_udf_int(thd, this);
  1491. }
  1494. longlong Item_sum_udf_int::val_int()
  1495. {
  1496.   DBUG_ASSERT(fixed == 1);
  1497.   DBUG_ENTER("Item_sum_udf_int::val_int");
  1498.   DBUG_PRINT("info",("result_type: %d  arg_count: %d",
  1499.      args[0]->result_type(), arg_count));
  1500.   DBUG_RETURN(udf.val_int(&null_value));
  1501. }
  1504. String *Item_sum_udf_int::val_str(String *str)
  1505. {
  1506.   DBUG_ASSERT(fixed == 1);
  1507.   longlong nr=val_int();
  1508.   if (null_value)
  1509.     return 0;
  1510.   str->set(nr, &my_charset_bin);
  1511.   return str;
  1512. }
  1514. /* Default max_length is max argument length */
  1516. void Item_sum_udf_str::fix_length_and_dec()
  1517. {
  1518.   DBUG_ENTER("Item_sum_udf_str::fix_length_and_dec");
  1519.   max_length=0;
  1520.   for (uint i = 0; i < arg_count; i++)
  1521.     set_if_bigger(max_length,args[i]->max_length);
  1522.   DBUG_VOID_RETURN;
  1523. }
  1526. Item *Item_sum_udf_str::copy_or_same(THD* thd)
  1527. {
  1528.   return new (thd->mem_root) Item_sum_udf_str(thd, this);
  1529. }
  1532. String *Item_sum_udf_str::val_str(String *str)
  1533. {
  1534.   DBUG_ASSERT(fixed == 1);
  1535.   DBUG_ENTER("Item_sum_udf_str::str");
  1536.   String *res=udf.val_str(str,&str_value);
  1537.   null_value = !res;
  1538.   DBUG_RETURN(res);
  1539. }
  1541. #endif /* HAVE_DLOPEN */
  1544. /*****************************************************************************
  1545.  GROUP_CONCAT function
  1547.  SQL SYNTAX:
  1548.   GROUP_CONCAT([DISTINCT] expr,... [ORDER BY col [ASC|DESC],...] 
  1549.     [SEPARATOR str_const])
  1551.  concat of values from "group by" operation
  1553.  BUGS
  1554.    DISTINCT and ORDER BY only works if ORDER BY uses all fields and only fields
  1555.    in expression list
  1556.    Blobs doesn't work with DISTINCT or ORDER BY
  1557. *****************************************************************************/
  1559. /*
  1560.   function of sort for syntax:
  1561.   GROUP_CONCAT(DISTINCT expr,...)
  1562. */
  1564. int group_concat_key_cmp_with_distinct(void* arg, byte* key1,
  1565.        byte* key2)
  1566. {
  1567.   Item_func_group_concat* grp_item= (Item_func_group_concat*)arg;
  1568.   Item **field_item, **end;
  1570.   for (field_item= grp_item->args, end= field_item + grp_item->arg_count_field;
  1571.        field_item < end;
  1572.        field_item++)
  1573.   {
  1574.     /*
  1575.       We have to use get_tmp_table_field() instead of
  1576.       real_item()->get_tmp_table_field() because we want the field in
  1577.       the temporary table, not the original field
  1578.     */
  1579.     Field *field= (*field_item)->get_tmp_table_field();
  1580.     /* 
  1581.       If field_item is a const item then either get_tp_table_field returns 0
  1582.       or it is an item over a const table. 
  1583.     */
  1584.     if (field && !(*field_item)->const_item())
  1585.     {
  1586.       int res;
  1587.       uint offset= field->offset();
  1588.       if ((res= field->key_cmp(key1 + offset, key2 + offset)))
  1589. return res;
  1590.     }
  1591.   }
  1592.   return 0;
  1593. }
  1596. /*
  1597.   function of sort for syntax:
  1598.   GROUP_CONCAT(expr,... ORDER BY col,... )
  1599. */
  1601. int group_concat_key_cmp_with_order(void* arg, byte* key1, byte* key2)
  1602. {
  1603.   Item_func_group_concat* grp_item= (Item_func_group_concat*) arg;
  1604.   ORDER **order_item, **end;
  1606.   for (order_item= grp_item->order, end=order_item+ grp_item->arg_count_order;
  1607.        order_item < end;
  1608.        order_item++)
  1609.   {
  1610.     Item *item= *(*order_item)->item;
  1611.     /*
  1612.       We have to use get_tmp_table_field() instead of
  1613.       real_item()->get_tmp_table_field() because we want the field in
  1614.       the temporary table, not the original field
  1615.     */
  1616.     Field *field= item->get_tmp_table_field();
  1617.     /* 
  1618.       If item is a const item then either get_tp_table_field returns 0
  1619.       or it is an item over a const table. 
  1620.     */
  1621.     if (field && !item->const_item())
  1622.     {
  1623.       int res;
  1624.       uint offset= field->offset();
  1625.       if ((res= field->key_cmp(key1 + offset, key2 + offset)))
  1626.         return (*order_item)->asc ? res : -res;
  1627.     }
  1628.   }
  1629.   /*
  1630.     We can't return 0 because in that case the tree class would remove this
  1631.     item as double value. This would cause problems for case-changes and
  1632.     if the the returned values are not the same we do the sort on.
  1633.   */
  1634.   return 1;
  1635. }
  1638. /*
  1639.   function of sort for syntax:
  1640.   GROUP_CONCAT(DISTINCT expr,... ORDER BY col,... )
  1642.   BUG:
  1643.     This doesn't work in the case when the order by contains data that
  1644.     is not part of the field list because tree-insert will not notice
  1645.     the duplicated values when inserting things sorted by ORDER BY
  1646. */
  1648. int group_concat_key_cmp_with_distinct_and_order(void* arg,byte* key1,
  1649.  byte* key2)
  1650. {
  1651.   if (!group_concat_key_cmp_with_distinct(arg,key1,key2))
  1652.     return 0;
  1653.   return(group_concat_key_cmp_with_order(arg,key1,key2));
  1654. }
  1657. /*
  1658.   Append data from current leaf to item->result
  1659. */
  1661. int dump_leaf_key(byte* key, uint32 count __attribute__((unused)),
  1662.                   Item_func_group_concat *item)
  1663. {
  1664.   char buff[MAX_FIELD_WIDTH];
  1665.   String tmp((char *)&buff,sizeof(buff),default_charset_info), tmp2;
  1667.   if (item->no_appended)
  1668.     item->no_appended= FALSE;
  1669.   else
  1670.     item->result.append(*item->separator);
  1672.   tmp.length(0);
  1673.   
  1674.   for (uint i= 0; i < item->arg_count_field; i++)
  1675.   {
  1676.     Item *show_item= item->args[i];
  1677.     if (!show_item->const_item())
  1678.     {
  1679.       /*
  1680. We have to use get_tmp_table_field() instead of
  1681. real_item()->get_tmp_table_field() because we want the field in
  1682. the temporary table, not the original field
  1683.       */
  1684.       Field *field= show_item->get_tmp_table_field();
  1685.       String *res;
  1686.       char *save_ptr= field->ptr;
  1687.       DBUG_ASSERT(field->offset() < item->table->reclength);
  1688.       field->ptr= (char *) key + field->offset();
  1689.       res= field->val_str(&tmp,&tmp2);
  1690.       item->result.append(*res);
  1691.       field->ptr= save_ptr;
  1692.     }
  1693.     else 
  1694.     {
  1695.       String *res= show_item->val_str(&tmp);
  1696.       if (res)
  1697.         item->result.append(*res);
  1698.     }
  1699.   }
  1701.   /* stop if length of result more than group_concat_max_len */  
  1702.   if (item->result.length() > item->group_concat_max_len)
  1703.   {
  1704.     item->count_cut_values++;
  1705.     item->result.length(item->group_concat_max_len);
  1706.     item->warning_for_row= TRUE;
  1707.     return 1;
  1708.   }
  1709.   return 0;
  1710. }
  1713. /*
  1714.   Constructor of Item_func_group_concat
  1715.   is_distinct - distinct
  1716.   is_select - list of expression for show values
  1717.   is_order - list of sort columns 
  1718.   is_separator - string value of separator
  1719. */
  1721. Item_func_group_concat::Item_func_group_concat(bool is_distinct,
  1722.        List<Item> *is_select,
  1723.        SQL_LIST *is_order,
  1724.        String *is_separator)
  1725.   :Item_sum(), tmp_table_param(0), max_elements_in_tree(0), warning(0),
  1726.    key_length(0), tree_mode(0), distinct(is_distinct), warning_for_row(0),
  1727.    separator(is_separator), tree(&tree_base), table(0),
  1728.    order(0), tables_list(0),
  1729.    arg_count_order(0), arg_count_field(0),
  1730.    count_cut_values(0)
  1731. {
  1732.   Item *item_select;
  1733.   Item **arg_ptr;
  1735.   original= 0;
  1736.   quick_group= 0;
  1737.   mark_as_sum_func();
  1738.   order= 0;
  1739.   group_concat_max_len= current_thd->variables.group_concat_max_len;
  1740.     
  1741.   arg_count_field= is_select->elements;
  1742.   arg_count_order= is_order ? is_order->elements : 0;
  1743.   arg_count= arg_count_field + arg_count_order;
  1744.   
  1745.   /*
  1746.     We need to allocate:
  1747.     args - arg_count_field+arg_count_order
  1748.            (for possible order items in temporare tables)
  1749.     order - arg_count_order
  1750.   */
  1751.   if (!(args= (Item**) sql_alloc(sizeof(Item*) * arg_count +
  1752.  sizeof(ORDER*)*arg_count_order)))
  1753.     return;
  1755.   order= (ORDER**)(args + arg_count);
  1757.   /* fill args items of show and sort */
  1758.   List_iterator_fast<Item> li(*is_select);
  1760.   for (arg_ptr=args ; (item_select= li++) ; arg_ptr++)
  1761.     *arg_ptr= item_select;
  1763.   if (arg_count_order) 
  1764.   {
  1765.     ORDER **order_ptr= order;
  1766.     for (ORDER *order_item= (ORDER*) is_order->first;
  1767.  order_item != NULL;
  1768.  order_item= order_item->next)
  1769.     {
  1770.       (*order_ptr++)= order_item;
  1771.       *arg_ptr= *order_item->item;
  1772.       order_item->item= arg_ptr++;
  1773.     }
  1774.   }
  1775. }
  1776.   
  1778. Item_func_group_concat::Item_func_group_concat(THD *thd,
  1779.        Item_func_group_concat *item)
  1780.   :Item_sum(thd, item),item_thd(thd),
  1781.   tmp_table_param(item->tmp_table_param),
  1782.   max_elements_in_tree(item->max_elements_in_tree),
  1783.   warning(item->warning),
  1784.   key_length(item->key_length), 
  1785.   tree_mode(item->tree_mode),
  1786.   distinct(item->distinct),
  1787.   warning_for_row(item->warning_for_row),
  1788.   separator(item->separator),
  1789.   tree(item->tree),
  1790.   table(item->table),
  1791.   order(item->order),
  1792.   tables_list(item->tables_list),
  1793.   group_concat_max_len(item->group_concat_max_len),
  1794.   arg_count_order(item->arg_count_order),
  1795.   arg_count_field(item->arg_count_field),
  1796.   field_list_offset(item->field_list_offset),
  1797.   count_cut_values(item->count_cut_values),
  1798.   original(item)
  1799. {
  1800.   quick_group= item->quick_group;
  1801. }
  1805. void Item_func_group_concat::cleanup()
  1806. {
  1807.   THD *thd= current_thd;
  1809.   DBUG_ENTER("Item_func_group_concat::cleanup");
  1810.   Item_sum::cleanup();
  1812.   /* Adjust warning message to include total number of cut values */
  1813.   if (warning)
  1814.   {
  1815.     char warn_buff[MYSQL_ERRMSG_SIZE];
  1816.     sprintf(warn_buff, ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
  1817.     warning->set_msg(thd, warn_buff);
  1818.     warning= 0;
  1819.   }
  1821.   /*
  1822.     Free table and tree if they belong to this item (if item have not pointer
  1823.     to original item from which was made copy => it own its objects )
  1824.   */
  1825.   if (!original)
  1826.   {
  1827.     if (table)
  1828.     {
  1829.       free_tmp_table(thd, table);
  1830.       table= 0;
  1831.     }
  1832.     delete tmp_table_param;
  1833.     tmp_table_param= 0;
  1834.     if (tree_mode)
  1835.     {
  1836.       tree_mode= 0;
  1837.       delete_tree(tree); 
  1838.     }
  1839.   }
  1840.   DBUG_VOID_RETURN;
  1841. }
  1844. Item_func_group_concat::~Item_func_group_concat()
  1845. {
  1846. }
  1849. Item *Item_func_group_concat::copy_or_same(THD* thd)
  1850. {
  1851.   return new (thd->mem_root) Item_func_group_concat(thd, this);
  1852. }
  1855. void Item_func_group_concat::clear()
  1856. {
  1857.   result.length(0);
  1858.   result.copy();
  1859.   null_value= TRUE;
  1860.   warning_for_row= FALSE;
  1861.   no_appended= TRUE;
  1862.   if (tree_mode)
  1863.     reset_tree(tree);
  1864. }
  1867. bool Item_func_group_concat::add()
  1868. {
  1869.   if (always_null)
  1870.     return 0;
  1871.   copy_fields(tmp_table_param);
  1872.   copy_funcs(tmp_table_param->items_to_copy);
  1874.   for (Item **arg= args, **arg_end= args + arg_count_field;
  1875.        arg < arg_end; arg++)
  1876.   {
  1877.     if (!(*arg)->const_item() &&
  1878.         (*arg)->get_tmp_table_field()->is_null_in_record(
  1879.           (const uchar*) table->record[0]))
  1880. return 0; // Skip row if it contains null
  1881.   }
  1883.   null_value= FALSE;
  1885.   TREE_ELEMENT *el= 0;                          // Only for safety
  1886.   if (tree_mode)
  1887.     el= tree_insert(tree, table->record[0], 0, tree->custom_arg);
  1888.   /*
  1889.     If the row is not a duplicate (el->count == 1)
  1890.     we can dump the row here in case of GROUP_CONCAT(DISTINCT...)
  1891.     instead of doing tree traverse later.
  1892.   */
  1893.   if (result.length() <= group_concat_max_len && 
  1894.       !warning_for_row &&
  1895.       (!tree_mode || (el->count == 1 && distinct && !arg_count_order)))
  1896.     dump_leaf_key(table->record[0], 1, this);
  1898.   return 0;
  1899. }
  1902. void Item_func_group_concat::reset_field()
  1903. {
  1904.   DBUG_ASSERT(0);
  1905. }
  1908. bool
  1909. Item_func_group_concat::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
  1910. {
  1911.   uint i; /* for loop variable */ 
  1912.   DBUG_ASSERT(fixed == 0);
  1914.   if (!thd->allow_sum_func)
  1915.   {
  1916.     my_error(ER_INVALID_GROUP_FUNC_USE,MYF(0));
  1917.     return 1;
  1918.   }
  1919.   
  1920.   thd->allow_sum_func= 0;
  1921.   maybe_null= 1;
  1922.   item_thd= thd;
  1924.   /*
  1925.     Fix fields for select list and ORDER clause
  1926.   */
  1928.   for (i=0 ; i < arg_count ; i++)  
  1929.   {
  1930.     if ((!args[i]->fixed && 
  1931.          args[i]->fix_fields(thd, tables, args + i)) ||
  1932.         args[i]->check_cols(1))
  1933.       return 1;
  1934.   }
  1936.   if (agg_item_charsets(collation, func_name(),
  1937.                         args, arg_count, MY_COLL_ALLOW_CONV))
  1938.     return 1;
  1940.   result.set_charset(collation.collation);
  1941.   result_field= 0;
  1942.   null_value= 1;
  1943.   max_length= group_concat_max_len;
  1944.   thd->allow_sum_func= 1;
  1945.   tables_list= tables;
  1946.   fixed= 1;
  1947.   return 0;
  1948. }
  1951. bool Item_func_group_concat::setup(THD *thd)
  1952. {
  1953.   List<Item> list;
  1954.   SELECT_LEX *select_lex= thd->lex->current_select;
  1955.   uint const_fields;
  1956.   byte *record;
  1957.   qsort_cmp2 compare_key;
  1958.   DBUG_ENTER("Item_func_group_concat::setup");
  1960.   if (select_lex->linkage == GLOBAL_OPTIONS_TYPE)
  1961.     DBUG_RETURN(1);
  1963.   if (!(tmp_table_param= new TMP_TABLE_PARAM))
  1964.     return 1;
  1965.   /* We'll convert all blobs to varchar fields in the temporary table */
  1966.   tmp_table_param->convert_blob_length= group_concat_max_len;
  1968.   /*
  1969.     push all not constant fields to list and create temp table
  1970.   */ 
  1971.   const_fields= 0;
  1972.   always_null= 0;
  1973.   for (uint i= 0; i < arg_count_field; i++)
  1974.   {
  1975.     Item *item= args[i];
  1976.     if (list.push_back(item))
  1977.       DBUG_RETURN(1);
  1978.     if (item->const_item())
  1979.     {
  1980.       const_fields++;
  1981.       (void) item->val_int();
  1982.       if (item->null_value)
  1983. always_null= 1;
  1984.     }
  1985.   }
  1986.   if (always_null)
  1987.     DBUG_RETURN(0);
  1988.         
  1989.   List<Item> all_fields(list);
  1990.   if (arg_count_order) 
  1991.   {
  1992.     bool hidden_group_fields;
  1993.     setup_group(thd, args, tables_list, list, all_fields, *order,
  1994.                 &hidden_group_fields);
  1995.   }
  1996.   
  1997.   count_field_types(tmp_table_param,all_fields,0);
  1998.   if (table)
  1999.   {
  2000.     /*
  2001.       We come here when we are getting the result from a temporary table,
  2002.       not the original tables used in the query
  2003.     */
  2004.     free_tmp_table(thd, table);
  2005.     tmp_table_param->cleanup();
  2006.   }
  2007.   /*
  2008.     We have to create a temporary table to get descriptions of fields 
  2009.     (types, sizes and so on).
  2011.     Note that in the table, we first have the ORDER BY fields, then the
  2012.     field list.
  2014.     We need to set set_sum_field in true for storing value of blob in buffer 
  2015.     of a record instead of a pointer of one. 
  2016.   */
  2017.   if (!(table=create_tmp_table(thd, tmp_table_param, all_fields, 
  2018.        (ORDER*) 0, 0, TRUE,
  2019.                                select_lex->options | thd->options,
  2020.        HA_POS_ERROR,(char *) "")))
  2021.     DBUG_RETURN(1);
  2022.   table->file->extra(HA_EXTRA_NO_ROWS);
  2023.   table->no_rows= 1;
  2025.   key_length= table->reclength;
  2026.   record= table->record[0];
  2028.   /* Offset to first result field in table */
  2029.   field_list_offset= table->fields - (list.elements - const_fields);
  2031.   if (tree_mode)
  2032.     delete_tree(tree);
  2034.   /* choose function of sort */  
  2035.   tree_mode= distinct || arg_count_order; 
  2036.   if (tree_mode)
  2037.   {
  2038.     if (arg_count_order)
  2039.     {
  2040.       if (distinct)
  2041.         compare_key= (qsort_cmp2) group_concat_key_cmp_with_distinct_and_order;
  2042.       else
  2043.         compare_key= (qsort_cmp2) group_concat_key_cmp_with_order;
  2044.     }
  2045.     else
  2046.     {
  2047.       compare_key= (qsort_cmp2) group_concat_key_cmp_with_distinct;
  2048.     }
  2049.     /*
  2050.       Create a tree of sort. Tree is used for a sort and a remove double 
  2051.       values (according with syntax of the function). If function doesn't
  2052.       contain DISTINCT and ORDER BY clauses, we don't create this tree.
  2053.     */
  2054.     init_tree(tree, min(thd->variables.max_heap_table_size,
  2055. thd->variables.sortbuff_size/16), 0,
  2056.               key_length, compare_key, 0, NULL, (void*) this);
  2057.     max_elements_in_tree= (key_length ? 
  2058.    thd->variables.max_heap_table_size/key_length : 1);
  2059.   };
  2061.   /*
  2062.     Copy table and tree_mode if they belong to this item (if item have not 
  2063.     pointer to original item from which was made copy => it own its objects)
  2064.   */
  2065.   if (original)
  2066.   {
  2067.     original->table= table;
  2068.     original->tree_mode= tree_mode;
  2069.   }
  2070.   DBUG_RETURN(0);
  2071. }
  2074. /* This is used by rollup to create a separate usable copy of the function */
  2076. void Item_func_group_concat::make_unique()
  2077. {
  2078.   table=0;
  2079.   original= 0;
  2080.   tree_mode= 0; // to prevent delete_tree call on uninitialized tree
  2081.   tree= &tree_base;
  2082. }
  2085. String* Item_func_group_concat::val_str(String* str)
  2086. {
  2087.   DBUG_ASSERT(fixed == 1);
  2088.   if (null_value)
  2089.     return 0;
  2090.   if (count_cut_values && !warning)
  2091.     /*
  2092.       ER_CUT_VALUE_GROUP_CONCAT needs an argument, but this gets set in
  2093.       Item_func_group_concat::cleanup().
  2094.     */
  2095.     warning= push_warning(item_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
  2096.                           ER_CUT_VALUE_GROUP_CONCAT,
  2097.                           ER(ER_CUT_VALUE_GROUP_CONCAT));
  2098.   if (result.length())
  2099.     return &result;
  2100.   if (tree_mode)
  2101.   {
  2102.     tree_walk(tree, (tree_walk_action)&dump_leaf_key, (void*)this,
  2103.               left_root_right);
  2104.   }
  2105.   return &result;
  2106. }
  2109. void Item_func_group_concat::print(String *str)
  2110. {
  2111.   str->append("group_concat(", 13);
  2112.   if (distinct)
  2113.     str->append("distinct ", 9);
  2114.   for (uint i= 0; i < arg_count_field; i++)
  2115.   {
  2116.     if (i)
  2117.       str->append(',');
  2118.     args[i]->print(str);
  2119.   }
  2120.   if (arg_count_order)
  2121.   {
  2122.     str->append(" order by ", 10);
  2123.     for (uint i= 0 ; i < arg_count_order ; i++)
  2124.     {
  2125.       if (i)
  2126. str->append(',');
  2127.       (*order[i]->item)->print(str);
  2128.     }
  2129.   }
  2130.   str->append(" separator '", 12);
  2131.   str->append(*separator);
  2132.   str->append("')", 2);
  2133. }