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

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /* classes for sum functions */
  14. #ifdef USE_PRAGMA_INTERFACE
  15. #pragma interface /* gcc class implementation */
  16. #endif
  17. #include <my_tree.h>
  18. class Item_sum :public Item_result_field
  19. {
  20. public:
  21.   enum Sumfunctype
  22.   { COUNT_FUNC,COUNT_DISTINCT_FUNC,SUM_FUNC,AVG_FUNC,MIN_FUNC,
  23.     MAX_FUNC, UNIQUE_USERS_FUNC,STD_FUNC,VARIANCE_FUNC,SUM_BIT_FUNC,
  24.     UDF_SUM_FUNC, GROUP_CONCAT_FUNC
  25.   };
  26.   Item **args, *tmp_args[2];
  27.   uint arg_count;
  28.   bool quick_group; /* If incremental update of fields */
  29.   void mark_as_sum_func();
  30.   Item_sum() :arg_count(0), quick_group(1) 
  31.   {
  32.     mark_as_sum_func();
  33.   }
  34.   Item_sum(Item *a)
  35.     :args(tmp_args), arg_count(1), quick_group(1)
  36.   {
  37.     args[0]=a;
  38.     mark_as_sum_func();
  39.   }
  40.   Item_sum( Item *a, Item *b )
  41.     :args(tmp_args), arg_count(2), quick_group(1)
  42.   {
  43.     args[0]=a; args[1]=b;
  44.     mark_as_sum_func();
  45.   }
  46.   Item_sum(List<Item> &list);
  47.   //Copy constructor, need to perform subselects with temporary tables
  48.   Item_sum(THD *thd, Item_sum *item);
  49.   enum Type type() const { return SUM_FUNC_ITEM; }
  50.   virtual enum Sumfunctype sum_func () const=0;
  51.   inline bool reset() { clear(); return add(); };
  52.   virtual void clear()= 0;
  53.   virtual bool add()=0;
  54.   /*
  55.     Called when new group is started and results are being saved in
  56.     a temporary table. Similar to reset(), but must also store value in
  57.     result_field. Like reset() it is supposed to reset start value to
  58.     default.
  59.   */
  60.   virtual void reset_field()=0;
  61.   /*
  62.     Called for each new value in the group, when temporary table is in use.
  63.     Similar to add(), but uses temporary table field to obtain current value,
  64.     Updated value is then saved in the field.
  65.   */
  66.   virtual void update_field()=0;
  67.   virtual bool keep_field_type(void) const { return 0; }
  68.   virtual void fix_length_and_dec() { maybe_null=1; null_value=1; }
  69.   virtual const char *func_name() const { return "?"; }
  70.   virtual Item *result_item(Field *field)
  71.     { return new Item_field(field);}
  72.   table_map used_tables() const { return ~(table_map) 0; } /* Not used */
  73.   bool const_item() const { return 0; }
  74.   bool is_null() { return null_value; }
  75.   void update_used_tables() { }
  76.   void make_field(Send_field *field);
  77.   void print(String *str);
  78.   void fix_num_length_and_dec();
  79.   void no_rows_in_result() { reset(); }
  80.   virtual bool setup(THD *thd) {return 0;}
  81.   virtual void make_unique() {}
  82.   Item *get_tmp_table_item(THD *thd);
  83.   bool walk (Item_processor processor, byte *argument);
  84. };
  85. class Item_sum_num :public Item_sum
  86. {
  87. public:
  88.   Item_sum_num() :Item_sum() {}
  89.   Item_sum_num(Item *item_par) :Item_sum(item_par) {}
  90.   Item_sum_num(Item *a, Item* b) :Item_sum(a,b) {}
  91.   Item_sum_num(List<Item> &list) :Item_sum(list) {}
  92.   Item_sum_num(THD *thd, Item_sum_num *item) :Item_sum(thd, item) {}
  93.   bool fix_fields(THD *, TABLE_LIST *, Item **);
  94.   longlong val_int()
  95.     { DBUG_ASSERT(fixed == 1); return (longlong) val(); } /* Real as default */
  96.   String *val_str(String*str);
  97.   void reset_field();
  98. };
  99. class Item_sum_int :public Item_sum_num
  100. {
  101. public:
  102.   Item_sum_int(Item *item_par) :Item_sum_num(item_par) {}
  103.   Item_sum_int(List<Item> &list) :Item_sum_num(list) {}
  104.   Item_sum_int(THD *thd, Item_sum_int *item) :Item_sum_num(thd, item) {}
  105.   double val() { DBUG_ASSERT(fixed == 1); return (double) val_int(); }
  106.   String *val_str(String*str);
  107.   enum Item_result result_type () const { return INT_RESULT; }
  108.   void fix_length_and_dec()
  109.   { decimals=0; max_length=21; maybe_null=null_value=0; }
  110. };
  111. class Item_sum_sum :public Item_sum_num
  112. {
  113.   double sum;
  114.   void fix_length_and_dec() { maybe_null=null_value=1; }
  115.   public:
  116.   Item_sum_sum(Item *item_par) :Item_sum_num(item_par),sum(0.0) {}
  117.   Item_sum_sum(THD *thd, Item_sum_sum *item) 
  118.     :Item_sum_num(thd, item), sum(item->sum) {}
  119.   enum Sumfunctype sum_func () const {return SUM_FUNC;}
  120.   void clear();
  121.   bool add();
  122.   double val();
  123.   void reset_field();
  124.   void update_field();
  125.   void no_rows_in_result() {}
  126.   const char *func_name() const { return "sum"; }
  127.   Item *copy_or_same(THD* thd);
  128. };
  129. class Item_sum_count :public Item_sum_int
  130. {
  131.   longlong count;
  132.   table_map used_table_cache;
  133.   public:
  134.   Item_sum_count(Item *item_par)
  135.     :Item_sum_int(item_par),count(0),used_table_cache(~(table_map) 0)
  136.   {}
  137.   Item_sum_count(THD *thd, Item_sum_count *item)
  138.     :Item_sum_int(thd, item), count(item->count),
  139.      used_table_cache(item->used_table_cache)
  140.   {}
  141.   table_map used_tables() const { return used_table_cache; }
  142.   bool const_item() const { return !used_table_cache; }
  143.   enum Sumfunctype sum_func () const { return COUNT_FUNC; }
  144.   void clear();
  145.   void no_rows_in_result() { count=0; }
  146.   bool add();
  147.   void make_const(longlong count_arg) { count=count_arg; used_table_cache=0; }
  148.   longlong val_int();
  149.   void reset_field();
  150.   void cleanup();
  151.   void update_field();
  152.   const char *func_name() const { return "count"; }
  153.   Item *copy_or_same(THD* thd);
  154. };
  155. class TMP_TABLE_PARAM;
  156. class Item_sum_count_distinct :public Item_sum_int
  157. {
  158.   TABLE *table;
  159.   table_map used_table_cache;
  160.   uint32 *field_lengths;
  161.   TMP_TABLE_PARAM *tmp_table_param;
  162.   TREE tree_base;
  163.   TREE *tree;
  164.   /*
  165.     Following is 0 normal object and pointer to original one for copy 
  166.     (to correctly free resources)
  167.   */
  168.   Item_sum_count_distinct *original;
  169.   uint key_length;
  170.   CHARSET_INFO *key_charset;
  171.   
  172.   /*
  173.     Calculated based on max_heap_table_size. If reached,
  174.     walk the tree and dump it into MyISAM table
  175.   */
  176.   uint max_elements_in_tree;
  177.   /*
  178.     The first few bytes of record ( at least one)
  179.     are just markers for deleted and NULLs. We want to skip them since
  180.     they will just bloat the tree without providing any valuable info
  181.   */
  182.   int rec_offset;
  183.   /*
  184.     If there are no blobs, we can use a tree, which
  185.     is faster than heap table. In that case, we still use the table
  186.     to help get things set up, but we insert nothing in it
  187.   */
  188.   bool use_tree;
  189.   bool always_null; // Set to 1 if the result is always NULL
  190.   int tree_to_myisam();
  191.   friend int composite_key_cmp(void* arg, byte* key1, byte* key2);
  192.   friend int simple_str_key_cmp(void* arg, byte* key1, byte* key2);
  193.   friend int simple_raw_key_cmp(void* arg, byte* key1, byte* key2);
  194.   friend int dump_leaf(byte* key, uint32 count __attribute__((unused)),
  195.        Item_sum_count_distinct* item);
  196.   public:
  197.   Item_sum_count_distinct(List<Item> &list)
  198.     :Item_sum_int(list), table(0), used_table_cache(~(table_map) 0),
  199.      tmp_table_param(0), tree(&tree_base), original(0), use_tree(0),
  200.      always_null(0)
  201.   { quick_group= 0; }
  202.   Item_sum_count_distinct(THD *thd, Item_sum_count_distinct *item)
  203.     :Item_sum_int(thd, item), table(item->table),
  204.      used_table_cache(item->used_table_cache),
  205.      field_lengths(item->field_lengths),
  206.      tmp_table_param(item->tmp_table_param),
  207.      tree(item->tree), original(item), key_length(item->key_length),
  208.      max_elements_in_tree(item->max_elements_in_tree),
  209.      rec_offset(item->rec_offset), use_tree(item->use_tree),
  210.      always_null(item->always_null)
  211.   {}
  212.   void cleanup();
  213.   table_map used_tables() const { return used_table_cache; }
  214.   enum Sumfunctype sum_func () const { return COUNT_DISTINCT_FUNC; }
  215.   void clear();
  216.   bool add();
  217.   longlong val_int();
  218.   void reset_field() { return ;} // Never called
  219.   void update_field() { return ; } // Never called
  220.   const char *func_name() const { return "count_distinct"; }
  221.   bool setup(THD *thd);
  222.   void make_unique();
  223.   Item *copy_or_same(THD* thd);
  224.   void no_rows_in_result() {}
  225.   void print(String *str);
  226. };
  227. /* Item to get the value of a stored sum function */
  228. class Item_sum_avg;
  229. class Item_avg_field :public Item_result_field
  230. {
  231. public:
  232.   Field *field;
  233.   Item_avg_field(Item_sum_avg *item);
  234.   enum Type type() const { return FIELD_AVG_ITEM; }
  235.   double val();
  236.   longlong val_int() { /* can't be fix_fields()ed */ return (longlong) val(); }
  237.   bool is_null() { (void) val_int(); return null_value; }
  238.   String *val_str(String*);
  239.   enum_field_types field_type() const { return MYSQL_TYPE_DOUBLE; }
  240.   void fix_length_and_dec() {}
  241. };
  242. class Item_sum_avg :public Item_sum_num
  243. {
  244.   void fix_length_and_dec()
  245.   {
  246.     decimals=min(decimals+4, NOT_FIXED_DEC);
  247.     maybe_null=1;
  248.   }
  249.   double sum;
  250.   ulonglong count;
  251.   public:
  252.   Item_sum_avg(Item *item_par) :Item_sum_num(item_par), sum(0.0), count(0) {}
  253.   Item_sum_avg(THD *thd, Item_sum_avg *item)
  254.     :Item_sum_num(thd, item), sum(item->sum), count(item->count) {}
  255.   enum Sumfunctype sum_func () const {return AVG_FUNC;}
  256.   void clear();
  257.   bool add();
  258.   double val();
  259.   void reset_field();
  260.   void update_field();
  261.   Item *result_item(Field *field)
  262.   { return new Item_avg_field(this); }
  263.   void no_rows_in_result() {}
  264.   const char *func_name() const { return "avg"; }
  265.   Item *copy_or_same(THD* thd);
  266. };
  267. class Item_sum_variance;
  268. class Item_variance_field :public Item_result_field
  269. {
  270. public:
  271.   Field *field;
  272.   Item_variance_field(Item_sum_variance *item);
  273.   enum Type type() const {return FIELD_VARIANCE_ITEM; }
  274.   double val();
  275.   longlong val_int() { /* can't be fix_fields()ed */ return (longlong) val(); }
  276.   String *val_str(String*);
  277.   bool is_null() { (void) val_int(); return null_value; }
  278.   enum_field_types field_type() const { return MYSQL_TYPE_DOUBLE; }
  279.   void fix_length_and_dec() {}
  280. };
  281. /*
  282.   variance(a) =
  283.   =  sum (ai - avg(a))^2 / count(a) )
  284.   =  sum (ai^2 - 2*ai*avg(a) + avg(a)^2) / count(a)
  285.   =  (sum(ai^2) - sum(2*ai*avg(a)) + sum(avg(a)^2))/count(a) = 
  286.   =  (sum(ai^2) - 2*avg(a)*sum(a) + count(a)*avg(a)^2)/count(a) = 
  287.   =  (sum(ai^2) - 2*sum(a)*sum(a)/count(a) + count(a)*sum(a)^2/count(a)^2 )/count(a) = 
  288.   =  (sum(ai^2) - 2*sum(a)^2/count(a) + sum(a)^2/count(a) )/count(a) = 
  289.   =  (sum(ai^2) - sum(a)^2/count(a))/count(a)
  290. */
  291. class Item_sum_variance : public Item_sum_num
  292. {
  293.   double sum, sum_sqr;
  294.   ulonglong count;
  295.   void fix_length_and_dec()
  296.   {
  297.     decimals=min(decimals+4, NOT_FIXED_DEC);
  298.     maybe_null=1;
  299.   }
  300.   public:
  301.   Item_sum_variance(Item *item_par) :Item_sum_num(item_par),count(0) {}
  302.   Item_sum_variance(THD *thd, Item_sum_variance *item):
  303.     Item_sum_num(thd, item), sum(item->sum), sum_sqr(item->sum_sqr),
  304.     count(item->count) {}
  305.   enum Sumfunctype sum_func () const { return VARIANCE_FUNC; }
  306.   void clear();
  307.   bool add();
  308.   double val();
  309.   void reset_field();
  310.   void update_field();
  311.   Item *result_item(Field *field)
  312.   { return new Item_variance_field(this); }
  313.   void no_rows_in_result() {}
  314.   const char *func_name() const { return "variance"; }
  315.   Item *copy_or_same(THD* thd);
  316. };
  317. class Item_sum_std;
  318. class Item_std_field :public Item_variance_field
  319. {
  320. public:
  321.   Item_std_field(Item_sum_std *item);
  322.   enum Type type() const { return FIELD_STD_ITEM; }
  323.   double val();
  324. };
  325. /*
  326.    standard_deviation(a) = sqrt(variance(a))
  327. */
  328. class Item_sum_std :public Item_sum_variance
  329. {
  330.   public:
  331.   Item_sum_std(Item *item_par) :Item_sum_variance(item_par) {}
  332.   Item_sum_std(THD *thd, Item_sum_std *item)
  333.     :Item_sum_variance(thd, item)
  334.     {}
  335.   enum Sumfunctype sum_func () const { return STD_FUNC; }
  336.   double val();
  337.   Item *result_item(Field *field)
  338.     { return new Item_std_field(this); }
  339.   const char *func_name() const { return "std"; }
  340.   Item *copy_or_same(THD* thd);
  341. };
  342. // This class is a string or number function depending on num_func
  343. class Item_sum_hybrid :public Item_sum
  344. {
  345.  protected:
  346.   String value,tmp_value;
  347.   double sum;
  348.   longlong sum_int;
  349.   Item_result hybrid_type;
  350.   enum_field_types hybrid_field_type;
  351.   int cmp_sign;
  352.   table_map used_table_cache;
  353.   bool was_values;  // Set if we have found at least one row (for max/min only)
  354.   public:
  355.   Item_sum_hybrid(Item *item_par,int sign)
  356.     :Item_sum(item_par), sum(0.0), sum_int(0),
  357.     hybrid_type(INT_RESULT), hybrid_field_type(FIELD_TYPE_LONGLONG),
  358.     cmp_sign(sign), used_table_cache(~(table_map) 0), was_values(TRUE)
  359.   { collation.set(&my_charset_bin); }
  360.   Item_sum_hybrid(THD *thd, Item_sum_hybrid *item):
  361.     Item_sum(thd, item), value(item->value),
  362.     sum(item->sum), sum_int(item->sum_int), hybrid_type(item->hybrid_type),
  363.     hybrid_field_type(item->hybrid_field_type),cmp_sign(item->cmp_sign), 
  364.     used_table_cache(item->used_table_cache),
  365.     was_values(TRUE)
  366.     { collation.set(item->collation); }
  367.   bool fix_fields(THD *, TABLE_LIST *, Item **);
  368.   table_map used_tables() const { return used_table_cache; }
  369.   bool const_item() const { return !used_table_cache; }
  370.   void clear();
  371.   double val();
  372.   longlong val_int();
  373.   void reset_field();
  374.   String *val_str(String *);
  375.   void make_const() { used_table_cache=0; }
  376.   bool keep_field_type(void) const { return 1; }
  377.   enum Item_result result_type () const { return hybrid_type; }
  378.   enum enum_field_types field_type() const { return hybrid_field_type; }
  379.   void update_field();
  380.   void min_max_update_str_field();
  381.   void min_max_update_real_field();
  382.   void min_max_update_int_field();
  383.   void cleanup();
  384.   bool any_value() { return was_values; }
  385.   void no_rows_in_result();
  386. };
  387. class Item_sum_min :public Item_sum_hybrid
  388. {
  389. public:
  390.   Item_sum_min(Item *item_par) :Item_sum_hybrid(item_par,1) {}
  391.   Item_sum_min(THD *thd, Item_sum_min *item) :Item_sum_hybrid(thd, item) {}
  392.   enum Sumfunctype sum_func () const {return MIN_FUNC;}
  393.   bool add();
  394.   const char *func_name() const { return "min"; }
  395.   Item *copy_or_same(THD* thd);
  396. };
  397. class Item_sum_max :public Item_sum_hybrid
  398. {
  399. public:
  400.   Item_sum_max(Item *item_par) :Item_sum_hybrid(item_par,-1) {}
  401.   Item_sum_max(THD *thd, Item_sum_max *item) :Item_sum_hybrid(thd, item) {}
  402.   enum Sumfunctype sum_func () const {return MAX_FUNC;}
  403.   bool add();
  404.   const char *func_name() const { return "max"; }
  405.   Item *copy_or_same(THD* thd);
  406. };
  407. class Item_sum_bit :public Item_sum_int
  408. {
  409. protected:
  410.   ulonglong reset_bits,bits;
  411. public:
  412.   Item_sum_bit(Item *item_par,ulonglong reset_arg)
  413.     :Item_sum_int(item_par),reset_bits(reset_arg),bits(reset_arg) {}
  414.   Item_sum_bit(THD *thd, Item_sum_bit *item):
  415.     Item_sum_int(thd, item), reset_bits(item->reset_bits), bits(item->bits) {}
  416.   enum Sumfunctype sum_func () const {return SUM_BIT_FUNC;}
  417.   void clear();
  418.   longlong val_int();
  419.   void reset_field();
  420.   void update_field();
  421.   void fix_length_and_dec()
  422.   { decimals=0; max_length=21; unsigned_flag=1; maybe_null=null_value=0; }
  423. };
  424. class Item_sum_or :public Item_sum_bit
  425. {
  426. public:
  427.   Item_sum_or(Item *item_par) :Item_sum_bit(item_par,LL(0)) {}
  428.   Item_sum_or(THD *thd, Item_sum_or *item) :Item_sum_bit(thd, item) {}
  429.   bool add();
  430.   const char *func_name() const { return "bit_or"; }
  431.   Item *copy_or_same(THD* thd);
  432. };
  433. class Item_sum_and :public Item_sum_bit
  434. {
  435.   public:
  436.   Item_sum_and(Item *item_par) :Item_sum_bit(item_par, ULONGLONG_MAX) {}
  437.   Item_sum_and(THD *thd, Item_sum_and *item) :Item_sum_bit(thd, item) {}
  438.   bool add();
  439.   const char *func_name() const { return "bit_and"; }
  440.   Item *copy_or_same(THD* thd);
  441. };
  442. class Item_sum_xor :public Item_sum_bit
  443. {
  444.   public:
  445.   Item_sum_xor(Item *item_par) :Item_sum_bit(item_par,LL(0)) {}
  446.   Item_sum_xor(THD *thd, Item_sum_xor *item) :Item_sum_bit(thd, item) {}
  447.   bool add();
  448.   const char *func_name() const { return "bit_xor"; }
  449.   Item *copy_or_same(THD* thd);
  450. };
  451. /*
  452.   User defined aggregates
  453. */
  454. #ifdef HAVE_DLOPEN
  455. class Item_udf_sum : public Item_sum
  456. {
  457. protected:
  458.   udf_handler udf;
  459. public:
  460.   Item_udf_sum(udf_func *udf_arg) :Item_sum(), udf(udf_arg) { quick_group=0;}
  461.   Item_udf_sum( udf_func *udf_arg, List<Item> &list )
  462.     :Item_sum( list ), udf(udf_arg)
  463.   { quick_group=0;}
  464.   Item_udf_sum(THD *thd, Item_udf_sum *item)
  465.     :Item_sum(thd, item), udf(item->udf) { udf.not_original= TRUE; }
  466.   const char *func_name() const { return udf.name(); }
  467.   bool fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
  468.   {
  469.     DBUG_ASSERT(fixed == 0);
  470.     fixed= 1;
  471.     return udf.fix_fields(thd,tables,this,this->arg_count,this->args);
  472.   }
  473.   enum Sumfunctype sum_func () const { return UDF_SUM_FUNC; }
  474.   virtual bool have_field_update(void) const { return 0; }
  475.   void clear();
  476.   bool add();
  477.   void reset_field() {};
  478.   void update_field() {};
  479.   void cleanup();
  480. };
  481. class Item_sum_udf_float :public Item_udf_sum
  482. {
  483.  public:
  484.   Item_sum_udf_float(udf_func *udf_arg) :Item_udf_sum(udf_arg) {}
  485.   Item_sum_udf_float(udf_func *udf_arg, List<Item> &list)
  486.     :Item_udf_sum(udf_arg,list) {}
  487.   Item_sum_udf_float(THD *thd, Item_sum_udf_float *item)
  488.     :Item_udf_sum(thd, item) {}
  489.   longlong val_int()
  490.     { DBUG_ASSERT(fixed == 1); return (longlong) Item_sum_udf_float::val(); }
  491.   double val();
  492.   String *val_str(String*str);
  493.   void fix_length_and_dec() { fix_num_length_and_dec(); }
  494.   Item *copy_or_same(THD* thd);
  495. };
  496. class Item_sum_udf_int :public Item_udf_sum
  497. {
  498. public:
  499.   Item_sum_udf_int(udf_func *udf_arg) :Item_udf_sum(udf_arg) {}
  500.   Item_sum_udf_int(udf_func *udf_arg, List<Item> &list)
  501.     :Item_udf_sum(udf_arg,list) {}
  502.   Item_sum_udf_int(THD *thd, Item_sum_udf_int *item)
  503.     :Item_udf_sum(thd, item) {}
  504.   longlong val_int();
  505.   double val()
  506.     { DBUG_ASSERT(fixed == 1); return (double) Item_sum_udf_int::val_int(); }
  507.   String *val_str(String*str);
  508.   enum Item_result result_type () const { return INT_RESULT; }
  509.   void fix_length_and_dec() { decimals=0; max_length=21; }
  510.   Item *copy_or_same(THD* thd);
  511. };
  512. class Item_sum_udf_str :public Item_udf_sum
  513. {
  514. public:
  515.   Item_sum_udf_str(udf_func *udf_arg) :Item_udf_sum(udf_arg) {}
  516.   Item_sum_udf_str(udf_func *udf_arg, List<Item> &list)
  517.     :Item_udf_sum(udf_arg,list) {}
  518.   Item_sum_udf_str(THD *thd, Item_sum_udf_str *item)
  519.     :Item_udf_sum(thd, item) {}
  520.   String *val_str(String *);
  521.   double val()
  522.   {
  523.     int err;
  524.     char *end_not_used;
  525.     String *res;
  526.     res=val_str(&str_value);
  527.     return res ? my_strntod(res->charset(),(char*) res->ptr(),res->length(),
  528.     &end_not_used, &err) : 0.0;
  529.   }
  530.   longlong val_int()
  531.   {
  532.     int err;
  533.     String *res;  res=val_str(&str_value);
  534.     return res ? my_strntoll(res->charset(),res->ptr(),res->length(),10, (char**) 0, &err) : (longlong) 0;
  535.   }
  536.   enum Item_result result_type () const { return STRING_RESULT; }
  537.   void fix_length_and_dec();
  538.   Item *copy_or_same(THD* thd);
  539. };
  540. #else /* Dummy functions to get sql_yacc.cc compiled */
  541. class Item_sum_udf_float :public Item_sum_num
  542. {
  543.  public:
  544.   Item_sum_udf_float(udf_func *udf_arg) :Item_sum_num() {}
  545.   Item_sum_udf_float(udf_func *udf_arg, List<Item> &list) :Item_sum_num() {}
  546.   Item_sum_udf_float(THD *thd, Item_sum_udf_float *item)
  547.     :Item_sum_num(thd, item) {}
  548.   enum Sumfunctype sum_func () const { return UDF_SUM_FUNC; }
  549.   double val() { DBUG_ASSERT(fixed == 1); return 0.0; }
  550.   void clear() {}
  551.   bool add() { return 0; }  
  552.   void update_field() {}
  553. };
  554. class Item_sum_udf_int :public Item_sum_num
  555. {
  556. public:
  557.   Item_sum_udf_int(udf_func *udf_arg) :Item_sum_num() {}
  558.   Item_sum_udf_int(udf_func *udf_arg, List<Item> &list) :Item_sum_num() {}
  559.   Item_sum_udf_int(THD *thd, Item_sum_udf_int *item)
  560.     :Item_sum_num(thd, item) {}
  561.   enum Sumfunctype sum_func () const { return UDF_SUM_FUNC; }
  562.   longlong val_int() { DBUG_ASSERT(fixed == 1); return 0; }
  563.   double val() { DBUG_ASSERT(fixed == 1); return 0; }
  564.   void clear() {}
  565.   bool add() { return 0; }  
  566.   void update_field() {}
  567. };
  568. class Item_sum_udf_str :public Item_sum_num
  569. {
  570. public:
  571.   Item_sum_udf_str(udf_func *udf_arg) :Item_sum_num() {}
  572.   Item_sum_udf_str(udf_func *udf_arg, List<Item> &list)  :Item_sum_num() {}
  573.   Item_sum_udf_str(THD *thd, Item_sum_udf_str *item)
  574.     :Item_sum_num(thd, item) {}
  575.   String *val_str(String *)
  576.     { DBUG_ASSERT(fixed == 1); null_value=1; return 0; }
  577.   double val() { DBUG_ASSERT(fixed == 1); null_value=1; return 0.0; }
  578.   longlong val_int() { DBUG_ASSERT(fixed == 1); null_value=1; return 0; }
  579.   enum Item_result result_type () const { return STRING_RESULT; }
  580.   void fix_length_and_dec() { maybe_null=1; max_length=0; }
  581.   enum Sumfunctype sum_func () const { return UDF_SUM_FUNC; }
  582.   void clear() {}
  583.   bool add() { return 0; }  
  584.   void update_field() {}
  585. };
  586. #endif /* HAVE_DLOPEN */
  587. class MYSQL_ERROR;
  588. class Item_func_group_concat : public Item_sum
  589. {
  590.   THD *item_thd;
  591.   TMP_TABLE_PARAM *tmp_table_param;
  592.   uint max_elements_in_tree;
  593.   MYSQL_ERROR *warning;
  594.   uint key_length;
  595.   bool tree_mode;
  596.   bool distinct;
  597.   bool warning_for_row;
  598.   bool always_null;
  599.   friend int group_concat_key_cmp_with_distinct(void* arg, byte* key1,
  600.       byte* key2);
  601.   friend int group_concat_key_cmp_with_order(void* arg, byte* key1,
  602.      byte* key2);
  603.   friend int group_concat_key_cmp_with_distinct_and_order(void* arg,
  604. byte* key1,
  605. byte* key2);
  606.   friend int dump_leaf_key(byte* key, uint32 count __attribute__((unused)),
  607.    Item_func_group_concat *group_concat_item);
  608.  public:
  609.   String result;
  610.   String *separator;
  611.   TREE tree_base;
  612.   TREE *tree;
  613.   TABLE *table;
  614.   ORDER **order;
  615.   TABLE_LIST *tables_list;
  616.   ulong group_concat_max_len;
  617.   uint arg_count_order;
  618.   uint arg_count_field;
  619.   uint field_list_offset;
  620.   uint count_cut_values;
  621.   bool no_appended;
  622.   /*
  623.     Following is 0 normal object and pointer to original one for copy 
  624.     (to correctly free resources)
  625.   */
  626.   Item_func_group_concat *original;
  627.   
  628.   Item_func_group_concat(bool is_distinct,List<Item> *is_select,
  629.                          SQL_LIST *is_order,String *is_separator);
  630.  
  631.   Item_func_group_concat(THD *thd, Item_func_group_concat *item);
  632.   ~Item_func_group_concat();
  633.   void cleanup();
  634.   enum Sumfunctype sum_func () const {return GROUP_CONCAT_FUNC;}
  635.   const char *func_name() const { return "group_concat"; }
  636.   virtual Item_result result_type () const { return STRING_RESULT; }
  637.   void clear();
  638.   bool add();
  639.   void reset_field();
  640.   bool fix_fields(THD *, TABLE_LIST *, Item **);
  641.   bool setup(THD *thd);
  642.   void make_unique();
  643.   virtual void update_field() {}
  644.   double val()
  645.   {
  646.     String *res;  res=val_str(&str_value);
  647.     return res ? my_atof(res->c_ptr()) : 0.0;
  648.   }
  649.   longlong val_int()
  650.   {
  651.     String *res;
  652.     char *end_ptr;
  653.     int error;
  654.     if (!(res= val_str(&str_value)))
  655.       return (longlong) 0;
  656.     end_ptr= (char*) res->ptr()+ res->length();
  657.     return my_strtoll10(res->ptr(), &end_ptr, &error);
  658.   }
  659.   String* val_str(String* str);
  660.   Item *copy_or_same(THD* thd);
  661.   void no_rows_in_result() {}
  662.   void print(String *str);
  663. };