item_sum.cc 74.4 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000-2003 MySQL AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
unknown's avatar
unknown committed
7

unknown's avatar
unknown committed
8 9 10 11
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
unknown's avatar
unknown committed
12

unknown's avatar
unknown committed
13 14 15 16 17 18 19 20 21 22 23 24
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/* Sum functions (COUNT, MIN...) */

#ifdef __GNUC__
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
25
#include "sql_select.h"
unknown's avatar
unknown committed
26

unknown's avatar
unknown committed
27
Item_sum::Item_sum(List<Item> &list)
28
  :arg_count(list.elements)
unknown's avatar
unknown committed
29 30 31 32
{
  if ((args=(Item**) sql_alloc(sizeof(Item*)*arg_count)))
  {
    uint i=0;
unknown's avatar
unknown committed
33
    List_iterator_fast<Item> li(list);
unknown's avatar
unknown committed
34 35 36 37 38 39 40
    Item *item;

    while ((item=li++))
    {
      args[i++]= item;
    }
  }
41
  mark_as_sum_func();
unknown's avatar
unknown committed
42 43 44
  list.empty();					// Fields are used
}

unknown's avatar
unknown committed
45 46 47 48 49

/*
  Constructor used in processing select with temporary tebles
*/

50
Item_sum::Item_sum(THD *thd, Item_sum *item):
unknown's avatar
unknown committed
51 52
  Item_result_field(thd, item), arg_count(item->arg_count),
  quick_group(item->quick_group)
53 54 55 56
{
  if (arg_count <= 2)
    args=tmp_args;
  else
unknown's avatar
unknown committed
57
    if (!(args= (Item**) thd->alloc(sizeof(Item*)*arg_count)))
58
      return;
unknown's avatar
unknown committed
59 60 61 62
  memcpy(args, item->args, sizeof(Item*)*arg_count);
}


63
void Item_sum::mark_as_sum_func()
64
{
unknown's avatar
unknown committed
65
  current_thd->lex->current_select->with_sum_func= 1;
unknown's avatar
unknown committed
66
  with_sum_func= 1;
67
}
unknown's avatar
unknown committed
68

69

unknown's avatar
unknown committed
70 71 72 73
void Item_sum::make_field(Send_field *tmp_field)
{
  if (args[0]->type() == Item::FIELD_ITEM && keep_field_type())
  {
74 75 76 77
    ((Item_field*) args[0])->field->make_field(tmp_field);
    tmp_field->db_name=(char*)"";
    tmp_field->org_table_name=tmp_field->table_name=(char*)"";
    tmp_field->org_col_name=tmp_field->col_name=name;
78 79
    if (maybe_null)
      tmp_field->flags&= ~NOT_NULL_FLAG;
unknown's avatar
unknown committed
80
  }
81 82
  else
    init_make_field(tmp_field, field_type());
unknown's avatar
unknown committed
83 84
}

85

unknown's avatar
unknown committed
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
void Item_sum::print(String *str)
{
  str->append(func_name());
  str->append('(');
  for (uint i=0 ; i < arg_count ; i++)
  {
    if (i)
      str->append(',');
    args[i]->print(str);
  }
  str->append(')');
}

void Item_sum::fix_num_length_and_dec()
{
  decimals=0;
  for (uint i=0 ; i < arg_count ; i++)
    set_if_bigger(decimals,args[i]->decimals);
  max_length=float_length(decimals);
}

107
Item *Item_sum::get_tmp_table_item(THD *thd)
108
{
109
  Item_sum* sum_item= (Item_sum *) copy_or_same(thd);
110 111
  if (sum_item && sum_item->result_field)	   // If not a const sum func
  {
112
    Field *result_field_tmp= sum_item->result_field;
113 114 115 116 117 118
    for (uint i=0 ; i < sum_item->arg_count ; i++)
    {
      Item *arg= sum_item->args[i];
      if (!arg->const_item())
      {
	if (arg->type() == Item::FIELD_ITEM)
119
	  ((Item_field*) arg)->field= result_field_tmp++;
120
	else
121
	  sum_item->args[i]= new Item_field(result_field_tmp++);
122 123 124 125 126
      }
    }
  }
  return sum_item;
}
unknown's avatar
unknown committed
127

unknown's avatar
unknown committed
128

129 130 131 132 133 134 135 136 137 138 139 140 141 142
bool Item_sum::walk (Item_processor processor, byte *argument)
{
  if (arg_count)
  {
    Item **arg,**arg_end;
    for (arg= args, arg_end= args+arg_count; arg != arg_end; arg++)
    {
      if ((*arg)->walk(processor, argument))
	return 1;
    }
  }
  return (this->*processor)(argument);
}

143

unknown's avatar
unknown committed
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158
Field *Item_sum::create_tmp_field(bool group, TABLE *table,
                                  uint convert_blob_length)
{
  switch (result_type()) {
  case REAL_RESULT:
    return new Field_double(max_length,maybe_null,name,table,decimals);
  case INT_RESULT:
    return new Field_longlong(max_length,maybe_null,name,table,unsigned_flag);
  case STRING_RESULT:
    if (max_length > 255 && convert_blob_length)
      return new Field_varstring(convert_blob_length, maybe_null,
                                 name, table,
                                 collation.collation);
    return make_string_field(table);
  case DECIMAL_RESULT:
unknown's avatar
unknown committed
159 160
    return new Field_new_decimal(max_length, maybe_null, name, table,
                                 decimals, unsigned_flag);
unknown's avatar
unknown committed
161 162 163 164 165 166 167 168 169
  case ROW_RESULT:
  default:
    // This case should never be choosen
    DBUG_ASSERT(0);
    return 0;
  }
}


unknown's avatar
unknown committed
170 171 172
String *
Item_sum_num::val_str(String *str)
{
173
  return val_string_from_real(str);
unknown's avatar
unknown committed
174 175 176
}


unknown's avatar
unknown committed
177 178
my_decimal *Item_sum_num::val_decimal(my_decimal *decimal_value)
{
179
  return val_decimal_from_real(decimal_value);
unknown's avatar
unknown committed
180 181 182
}


unknown's avatar
unknown committed
183 184 185
String *
Item_sum_int::val_str(String *str)
{
186 187 188 189 190 191 192
  return val_string_from_int(str);
}


my_decimal *Item_sum_int::val_decimal(my_decimal *decimal_value)
{
  return val_decimal_from_int(decimal_value);
unknown's avatar
unknown committed
193 194 195 196
}


bool
unknown's avatar
unknown committed
197
Item_sum_num::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
unknown's avatar
unknown committed
198
{
199
  DBUG_ASSERT(fixed == 0);
unknown's avatar
unknown committed
200

unknown's avatar
unknown committed
201 202
  if (!thd->allow_sum_func)
  {
unknown's avatar
unknown committed
203 204
    my_message(ER_INVALID_GROUP_FUNC_USE, ER(ER_INVALID_GROUP_FUNC_USE),
               MYF(0));
unknown's avatar
unknown committed
205
    return TRUE;
unknown's avatar
unknown committed
206 207 208 209 210 211
  }
  thd->allow_sum_func=0;			// No included group funcs
  decimals=0;
  maybe_null=0;
  for (uint i=0 ; i < arg_count ; i++)
  {
unknown's avatar
unknown committed
212
    if (args[i]->fix_fields(thd, tables, args + i) || args[i]->check_cols(1))
unknown's avatar
unknown committed
213
      return TRUE;
unknown's avatar
unknown committed
214
    set_if_bigger(decimals, args[i]->decimals);
unknown's avatar
unknown committed
215 216 217 218 219 220 221
    maybe_null |= args[i]->maybe_null;
  }
  result_field=0;
  max_length=float_length(decimals);
  null_value=1;
  fix_length_and_dec();
  thd->allow_sum_func=1;			// Allow group functions
222
  fixed= 1;
unknown's avatar
unknown committed
223
  return FALSE;
unknown's avatar
unknown committed
224 225 226
}


unknown's avatar
unknown committed
227 228 229 230 231
Item_sum_hybrid::Item_sum_hybrid(THD *thd, Item_sum_hybrid *item)
  :Item_sum(thd, item), value(item->value), hybrid_type(item->hybrid_type),
  hybrid_field_type(item->hybrid_field_type), cmp_sign(item->cmp_sign),
  used_table_cache(item->used_table_cache), was_values(item->was_values)
{
232 233
  /* copy results from old value */
  switch (hybrid_type) {
unknown's avatar
unknown committed
234 235 236 237 238 239 240 241 242
  case INT_RESULT:
    sum_int= item->sum_int;
    break;
  case DECIMAL_RESULT:
    my_decimal2decimal(&item->sum_dec, &sum_dec);
    break;
  case REAL_RESULT:
    sum= item->sum;
    break;
unknown's avatar
unknown committed
243 244
  case STRING_RESULT: // This can happen with ROLLUP. Note that the value is already
    break;            // copied at function call.
unknown's avatar
unknown committed
245 246 247 248 249 250 251
  case ROW_RESULT:
  default:
    DBUG_ASSERT(0);
  }
  collation.set(item->collation);
}

unknown's avatar
unknown committed
252
bool
unknown's avatar
unknown committed
253
Item_sum_hybrid::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
unknown's avatar
unknown committed
254
{
255
  DBUG_ASSERT(fixed == 0);
unknown's avatar
unknown committed
256

257
  Item *item= args[0];
unknown's avatar
unknown committed
258 259
  if (!thd->allow_sum_func)
  {
unknown's avatar
unknown committed
260 261
    my_message(ER_INVALID_GROUP_FUNC_USE, ER(ER_INVALID_GROUP_FUNC_USE),
               MYF(0));
unknown's avatar
unknown committed
262
    return TRUE;
unknown's avatar
unknown committed
263 264
  }
  thd->allow_sum_func=0;			// No included group funcs
265 266

  // 'item' can be changed during fix_fields
267
  if (!item->fixed &&
268 269
      item->fix_fields(thd, tables, args) ||
      (item= args[0])->check_cols(1))
unknown's avatar
unknown committed
270
    return TRUE;
unknown's avatar
unknown committed
271
  decimals=item->decimals;
272

273
  switch (hybrid_type= item->result_type()) {
unknown's avatar
unknown committed
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
  case INT_RESULT:
    max_length= 20;
    sum_int= 0;
    break;
  case DECIMAL_RESULT:
    max_length= item->max_length;
    my_decimal_set_zero(&sum_dec);
    break;
  case REAL_RESULT:
    max_length= float_length(decimals);
    sum= 0.0;
    break;
  case STRING_RESULT:
    max_length= item->max_length;
    break;
  case ROW_RESULT:
  default:
    DBUG_ASSERT(0);
  };
293 294
  /* MIN/MAX can return NULL for empty set indepedent of the used column */
  maybe_null= 1;
295
  unsigned_flag=item->unsigned_flag;
296
  collation.set(item->collation);
unknown's avatar
unknown committed
297 298 299 300
  result_field=0;
  null_value=1;
  fix_length_and_dec();
  thd->allow_sum_func=1;			// Allow group functions
301 302 303 304
  if (item->type() == Item::FIELD_ITEM)
    hybrid_field_type= ((Item_field*) item)->field->type();
  else
    hybrid_field_type= Item::field_type();
305
  fixed= 1;
unknown's avatar
unknown committed
306
  return FALSE;
unknown's avatar
unknown committed
307 308
}

309 310 311 312 313 314 315
Field *Item_sum_hybrid::create_tmp_field(bool group, TABLE *table,
					 uint convert_blob_length)
{
  if (args[0]->type() == Item::FIELD_ITEM)
  {
    Field *field= ((Item_field*) args[0])->field;
    
unknown's avatar
unknown committed
316 317
    if ((field= create_tmp_field_from_field(current_thd, field, name, table,
					    NULL, convert_blob_length)))
318 319 320 321 322 323
      field->flags&= ~NOT_NULL_FLAG;
    return field;
  }
  return Item_sum::create_tmp_field(group, table, convert_blob_length);
}

unknown's avatar
unknown committed
324 325 326 327 328

/***********************************************************************
** reset and add of sum_func
***********************************************************************/

unknown's avatar
unknown committed
329 330 331 332
Item_sum_sum::Item_sum_sum(THD *thd, Item_sum_sum *item) 
  :Item_sum_num(thd, item), hybrid_type(item->hybrid_type),
   curr_dec_buff(item->curr_dec_buff)
{
333
  /* TODO: check if the following assignments are really needed */
unknown's avatar
unknown committed
334 335 336 337 338 339 340 341 342
  if (hybrid_type == DECIMAL_RESULT)
  {
    my_decimal2decimal(item->dec_buffs, dec_buffs);
    my_decimal2decimal(item->dec_buffs + 1, dec_buffs + 1);
  }
  else
    sum= item->sum;
}

343
Item *Item_sum_sum::copy_or_same(THD* thd)
unknown's avatar
unknown committed
344
{
unknown's avatar
unknown committed
345
  return new (thd->mem_root) Item_sum_sum(thd, this);
unknown's avatar
unknown committed
346 347
}

348

349
void Item_sum_sum::clear()
350
{
unknown's avatar
unknown committed
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
  DBUG_ENTER("Item_sum_sum::clear");
  null_value=1;
  if (hybrid_type == DECIMAL_RESULT)
  {
    curr_dec_buff= 0;
    my_decimal_set_zero(dec_buffs);
  }
  else
    sum= 0.0;
  DBUG_VOID_RETURN;
}


void Item_sum_sum::fix_length_and_dec()
{
  DBUG_ENTER("Item_sum_sum::fix_length_and_dec");
  maybe_null=null_value=1;
  decimals= args[0]->decimals;
369
  switch (args[0]->result_type()) {
unknown's avatar
unknown committed
370 371 372 373 374 375 376
  case REAL_RESULT:
  case STRING_RESULT:
    hybrid_type= REAL_RESULT;
    sum= 0.0;
    break;
  case INT_RESULT:
  case DECIMAL_RESULT:
unknown's avatar
unknown committed
377
  {
unknown's avatar
unknown committed
378
    /* SUM result can't be longer than length(arg) + length(MAX_ROWS) */
unknown's avatar
unknown committed
379 380 381
    int precision= args[0]->decimal_precision() + DECIMAL_LONGLONG_DIGITS;
    max_length= my_decimal_precision_to_length(precision, decimals,
                                               unsigned_flag);
unknown's avatar
unknown committed
382 383 384 385
    curr_dec_buff= 0;
    hybrid_type= DECIMAL_RESULT;
    my_decimal_set_zero(dec_buffs);
    break;
unknown's avatar
unknown committed
386
  }
unknown's avatar
unknown committed
387 388 389 390 391 392 393 394 395 396 397 398
  case ROW_RESULT:
  default:
    DBUG_ASSERT(0);
  }
  DBUG_PRINT("info", ("Type: %s (%d, %d)",
                      (hybrid_type == REAL_RESULT ? "REAL_RESULT" :
                       hybrid_type == DECIMAL_RESULT ? "DECIMAL_RESULT" :
                       hybrid_type == INT_RESULT ? "INT_RESULT" :
                       "--ILLEGAL!!!--"),
                      max_length,
                      (int)decimals));
  DBUG_VOID_RETURN;
399 400 401
}


unknown's avatar
unknown committed
402 403
bool Item_sum_sum::add()
{
unknown's avatar
unknown committed
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
  DBUG_ENTER("Item_sum_sum::add");
  if (hybrid_type == DECIMAL_RESULT)
  {
    my_decimal value, *val= args[0]->val_decimal(&value);
    if (!args[0]->null_value)
    {
      my_decimal_add(E_DEC_FATAL_ERROR, dec_buffs + (curr_dec_buff^1),
                     val, dec_buffs + curr_dec_buff);
      curr_dec_buff^= 1;
      null_value= 0;
    }
  }
  else
  {
    sum+= args[0]->val_real();
    if (!args[0]->null_value)
      null_value= 0;
  }
  DBUG_RETURN(0);
}


longlong Item_sum_sum::val_int()
{
  DBUG_ASSERT(fixed == 1);
  if (hybrid_type == DECIMAL_RESULT)
  {
    longlong result;
    my_decimal2int(E_DEC_FATAL_ERROR, dec_buffs + curr_dec_buff, unsigned_flag,
                   &result);
    return result;
  }
436
  return (longlong) val_real();
unknown's avatar
unknown committed
437 438
}

439

440
double Item_sum_sum::val_real()
unknown's avatar
unknown committed
441
{
442
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
443 444
  if (hybrid_type == DECIMAL_RESULT)
    my_decimal2double(E_DEC_FATAL_ERROR, dec_buffs + curr_dec_buff, &sum);
unknown's avatar
unknown committed
445 446 447 448
  return sum;
}


449
String *Item_sum_sum::val_str(String *str)
unknown's avatar
unknown committed
450 451
{
  if (hybrid_type == DECIMAL_RESULT)
452 453
    return val_string_from_decimal(str);
  return val_string_from_real(str);
unknown's avatar
unknown committed
454 455 456 457 458
}


my_decimal *Item_sum_sum::val_decimal(my_decimal *val)
{
459 460 461
  if (hybrid_type == DECIMAL_RESULT)
    return (dec_buffs + curr_dec_buff);
  return val_decimal_from_real(val);
unknown's avatar
unknown committed
462 463
}

464
/***************************************************************************/
465

466 467 468
C_MODE_START

/* Declarations for auxilary C-callbacks */
469

470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
static int simple_raw_key_cmp(void* arg, const void* key1, const void* key2)
{
    return memcmp(key1, key2, *(uint *) arg);
}


static int item_sum_distinct_walk(void *element, element_count num_of_dups,
                                  void *item)
{
    return ((Item_sum_distinct*) (item))->unique_walk_function(element);
}

C_MODE_END

/* Item_sum_distinct */

Item_sum_distinct::Item_sum_distinct(Item *item_arg)
  :Item_sum_num(item_arg), tree(0)
488 489 490 491 492 493 494 495 496 497 498
{
  /*
    quick_group is an optimizer hint, which means that GROUP BY can be
    handled with help of index on grouped columns.
    By setting quick_group to zero we force creation of temporary table
    to perform GROUP BY.
  */
  quick_group= 0;
}


499 500 501
Item_sum_distinct::Item_sum_distinct(THD *thd, Item_sum_distinct *original)
  :Item_sum_num(thd, original), val(original->val), tree(0),
  table_field_type(original->table_field_type)
502 503 504 505 506
{
  quick_group= 0;
}


507 508 509 510 511 512 513 514 515
/*
  Behaves like an Integer except to fix_length_and_dec().
  Additionally div() converts val with this traits to a val with true
  decimal traits along with conversion of integer value to decimal value.
  This is to speedup SUM/AVG(DISTINCT) evaluation for 8-32 bit integer
  values.
*/
struct Hybrid_type_traits_fast_decimal: public
       Hybrid_type_traits_integer
unknown's avatar
unknown committed
516
{
517 518 519 520 521
  virtual Item_result type() const { return DECIMAL_RESULT; }
  virtual void fix_length_and_dec(Item *item, Item *arg) const
  { Hybrid_type_traits_decimal::instance()->fix_length_and_dec(item, arg); }

  virtual void div(Hybrid_type *val, ulonglong u) const
unknown's avatar
unknown committed
522
  {
523 524 525 526
    int2my_decimal(E_DEC_FATAL_ERROR, val->integer, 0, val->dec_buf);
    val->used_dec_buf_no= 0;
    val->traits= Hybrid_type_traits_decimal::instance();
    val->traits->div(val, u);
unknown's avatar
unknown committed
527
  }
unknown's avatar
unknown committed
528
  static const Hybrid_type_traits_fast_decimal *instance();
529
};
unknown's avatar
unknown committed
530

unknown's avatar
unknown committed
531 532 533 534 535 536 537
static const Hybrid_type_traits_fast_decimal fast_decimal_traits_instance;

const Hybrid_type_traits_fast_decimal
  *Hybrid_type_traits_fast_decimal::instance()
{
  return &fast_decimal_traits_instance;
}
unknown's avatar
unknown committed
538

539
void Item_sum_distinct::fix_length_and_dec()
540
{
541
  DBUG_ASSERT(args[0]->fixed);
542

543
  table_field_type= args[0]->field_type();
544

545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579
  /* Adjust tmp table type according to the chosen aggregation type */
  switch (args[0]->result_type()) {
  case STRING_RESULT:
  case REAL_RESULT:
    val.traits= Hybrid_type_traits::instance();
    if (table_field_type != MYSQL_TYPE_FLOAT)
      table_field_type= MYSQL_TYPE_DOUBLE;
    break;
  case INT_RESULT:
  /*
    Preserving int8, int16, int32 field types gives ~10% performance boost
    as the size of result tree becomes significantly smaller.
    Another speed up we gain by using longlong for intermediate
    calculations. The range of int64 is enough to hold sum 2^32 distinct
    integers each <= 2^32.
  */
  if (table_field_type == MYSQL_TYPE_INT24 ||
      table_field_type >= MYSQL_TYPE_TINY &&
      table_field_type <= MYSQL_TYPE_LONG)
  {
    val.traits= Hybrid_type_traits_fast_decimal::instance();
    break;
  }
  table_field_type= MYSQL_TYPE_LONGLONG;
  /* fallthrough */
  case DECIMAL_RESULT:
    val.traits= Hybrid_type_traits_decimal::instance();
    if (table_field_type != MYSQL_TYPE_LONGLONG)
      table_field_type= MYSQL_TYPE_NEWDECIMAL;
    break;
  case ROW_RESULT:
  default:
    DBUG_ASSERT(0);
  }
  val.traits->fix_length_and_dec(this, args[0]);
580 581 582
}


583
bool Item_sum_distinct::setup(THD *thd)
584
{
585 586 587
  List<create_field> field_list;
  create_field field_def;                              /* field definition */
  DBUG_ENTER("Item_sum_distinct::setup");
unknown's avatar
unknown committed
588
  DBUG_ASSERT(tree == 0);
589 590

  /*
591 592 593
    Virtual table and the tree are created anew on each re-execution of
    PS/SP. Hence all further allocations are performed in the runtime
    mem_root.
594
  */
595 596 597
  if (field_list.push_back(&field_def))
    return TRUE;

598
  null_value= maybe_null= 1;
599 600 601 602 603 604 605 606 607
  quick_group= 0;

  DBUG_ASSERT(args[0]->fixed);

  field_def.init_for_tmp_table(table_field_type, args[0]->max_length,
                               args[0]->decimals, args[0]->maybe_null,
                               args[0]->unsigned_flag);

  if (! (table= create_virtual_tmp_table(thd, field_list)))
unknown's avatar
unknown committed
608
    return TRUE;
609 610 611

  /* XXX: check that the case of CHAR(0) works OK */
  tree_key_length= table->s->reclength - table->s->null_bytes;
612 613

  /*
614 615 616 617
    Unique handles all unique elements in a tree until they can't fit
    in.  Then the tree is dumped to the temporary file. We can use
    simple_raw_key_cmp because the table contains numbers only; decimals
    are converted to binary representation as well.
618
  */
619
  tree= new Unique(simple_raw_key_cmp, &tree_key_length, tree_key_length,
620 621
                   thd->variables.max_heap_table_size);

622
  DBUG_RETURN(tree == 0);
623 624 625
}


626
bool Item_sum_distinct::add()
627
{
628 629
  args[0]->save_in_field(table->field[0], FALSE);
  if (!table->field[0]->is_null())
630
  {
631 632 633 634 635 636 637
    DBUG_ASSERT(tree);
    null_value= 0;
    /*
      '0' values are also stored in the tree. This doesn't matter
      for SUM(DISTINCT), but is important for AVG(DISTINCT)
    */
    return tree->unique_add(table->field[0]->ptr);
638
  }
639
  return 0;
unknown's avatar
unknown committed
640 641 642
}


643
bool Item_sum_distinct::unique_walk_function(void *element)
unknown's avatar
unknown committed
644
{
645 646 647 648
  memcpy(table->field[0]->ptr, element, tree_key_length);
  ++count;
  val.traits->add(&val, table->field[0]);
  return 0;
unknown's avatar
unknown committed
649 650 651
}


652
void Item_sum_distinct::clear()
unknown's avatar
unknown committed
653
{
654 655 656 657 658
  DBUG_ENTER("Item_sum_distinct::clear");
  DBUG_ASSERT(tree != 0);                        /* we always have a tree */
  null_value= 1;
  tree->reset();
  DBUG_VOID_RETURN;
659 660
}

661 662 663 664 665 666
void Item_sum_distinct::cleanup()
{
  Item_sum_num::cleanup();
  delete tree;
  tree= 0;
  table= 0;
unknown's avatar
unknown committed
667 668
}

669 670 671 672
Item_sum_distinct::~Item_sum_distinct()
{
  delete tree;
  /* no need to free the table */
673 674
}

675

676
void Item_sum_distinct::calculate_val_and_count()
677
{
678 679
  count= 0;
  val.traits->set_zero(&val);
680 681 682 683
  /*
    We don't have a tree only if 'setup()' hasn't been called;
    this is the case of sql_select.cc:return_zero_rows.
  */
684
  if (tree)
unknown's avatar
unknown committed
685
  {
686 687
    table->field[0]->set_notnull();
    tree->walk(item_sum_distinct_walk, (void*) this);
unknown's avatar
unknown committed
688
  }
689 690
}

unknown's avatar
unknown committed
691

692
double Item_sum_distinct::val_real()
unknown's avatar
unknown committed
693
{
694 695
  calculate_val_and_count();
  return val.traits->val_real(&val);
unknown's avatar
unknown committed
696 697 698
}


699
my_decimal *Item_sum_distinct::val_decimal(my_decimal *to)
unknown's avatar
unknown committed
700
{
701 702 703 704
  calculate_val_and_count();
  if (null_value)
    return 0;
  return val.traits->val_decimal(&val, to);
unknown's avatar
unknown committed
705 706 707
}


708
longlong Item_sum_distinct::val_int()
unknown's avatar
unknown committed
709
{
710 711 712 713 714 715 716 717 718 719 720
  calculate_val_and_count();
  return val.traits->val_int(&val, unsigned_flag);
}


String *Item_sum_distinct::val_str(String *str)
{
  calculate_val_and_count();
  if (null_value)
    return 0;
  return val.traits->val_str(&val, str, decimals);
unknown's avatar
unknown committed
721 722
}

723 724 725 726
/* end of Item_sum_distinct */

/* Item_sum_avg_distinct */

727 728 729 730
void
Item_sum_avg_distinct::fix_length_and_dec()
{
  Item_sum_distinct::fix_length_and_dec();
unknown's avatar
unknown committed
731
  prec_increment= current_thd->variables.div_precincrement;
732 733 734 735
  /*
    AVG() will divide val by count. We need to reserve digits
    after decimal point as the result can be fractional.
  */
unknown's avatar
unknown committed
736
  decimals= min(decimals + prec_increment, NOT_FIXED_DEC);
737 738 739
}


740 741 742 743 744 745 746
void
Item_sum_avg_distinct::calculate_val_and_count()
{
  Item_sum_distinct::calculate_val_and_count();
  if (count)
    val.traits->div(&val, count);
}
unknown's avatar
unknown committed
747

748

749
Item *Item_sum_count::copy_or_same(THD* thd)
unknown's avatar
unknown committed
750
{
unknown's avatar
unknown committed
751
  return new (thd->mem_root) Item_sum_count(thd, this);
unknown's avatar
unknown committed
752 753
}

754

755
void Item_sum_count::clear()
756
{
757
  count= 0;
758 759 760
}


unknown's avatar
unknown committed
761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
bool Item_sum_count::add()
{
  if (!args[0]->maybe_null)
    count++;
  else
  {
    (void) args[0]->val_int();
    if (!args[0]->null_value)
      count++;
  }
  return 0;
}

longlong Item_sum_count::val_int()
{
776
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
777 778 779
  return (longlong) count;
}

780 781 782 783 784 785 786 787 788 789

void Item_sum_count::cleanup()
{
  DBUG_ENTER("Item_sum_count::cleanup");
  Item_sum_int::cleanup();
  used_table_cache= ~(table_map) 0;
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
790
/*
791
  Avgerage
unknown's avatar
unknown committed
792
*/
unknown's avatar
unknown committed
793 794 795 796
void Item_sum_avg::fix_length_and_dec()
{
  Item_sum_sum::fix_length_and_dec();
  maybe_null=null_value=1;
unknown's avatar
unknown committed
797
  prec_increment= current_thd->variables.div_precincrement;
unknown's avatar
unknown committed
798 799
  if (hybrid_type == DECIMAL_RESULT)
  {
unknown's avatar
unknown committed
800 801 802 803 804 805
    int precision= args[0]->decimal_precision() + prec_increment;
    decimals= min(args[0]->decimals + prec_increment, DECIMAL_MAX_SCALE);
    max_length= my_decimal_precision_to_length(precision, decimals,
                                               unsigned_flag);
    f_precision= min(precision+DECIMAL_LONGLONG_DIGITS, DECIMAL_MAX_PRECISION);
    f_scale=  args[0]->decimals;
unknown's avatar
unknown committed
806 807
    dec_bin_size= my_decimal_get_binary_size(f_precision, f_scale);
  }
unknown's avatar
unknown committed
808 809
  else
    decimals= min(args[0]->decimals + prec_increment, NOT_FIXED_DEC);
unknown's avatar
unknown committed
810 811
}

unknown's avatar
unknown committed
812

813
Item *Item_sum_avg::copy_or_same(THD* thd)
unknown's avatar
unknown committed
814
{
unknown's avatar
unknown committed
815
  return new (thd->mem_root) Item_sum_avg(thd, this);
unknown's avatar
unknown committed
816 817
}

818

unknown's avatar
unknown committed
819 820 821
Field *Item_sum_avg::create_tmp_field(bool group, TABLE *table,
                                      uint convert_blob_len)
{
822
  if (group)
unknown's avatar
unknown committed
823
  {
824 825 826 827 828 829 830 831
    /*
      We must store both value and counter in the temporary table in one field.
      The easyest way is to do this is to store both value in a string
      and unpack on access.
    */
    return new Field_string(((hybrid_type == DECIMAL_RESULT) ?
                             dec_bin_size : sizeof(double)) + sizeof(longlong),
                            0, name, table, &my_charset_bin);
unknown's avatar
unknown committed
832
  }
833
  if (hybrid_type == DECIMAL_RESULT)
unknown's avatar
unknown committed
834 835
    return new Field_new_decimal(max_length, maybe_null, name, table,
                                 decimals, unsigned_flag);
836
  return new Field_double(max_length, maybe_null, name, table, decimals);
unknown's avatar
unknown committed
837 838 839
}


840
void Item_sum_avg::clear()
841
{
unknown's avatar
unknown committed
842 843
  Item_sum_sum::clear();
  count=0;
844 845 846
}


unknown's avatar
unknown committed
847 848
bool Item_sum_avg::add()
{
unknown's avatar
unknown committed
849 850
  if (Item_sum_sum::add())
    return TRUE;
unknown's avatar
unknown committed
851 852
  if (!args[0]->null_value)
    count++;
unknown's avatar
unknown committed
853
  return FALSE;
unknown's avatar
unknown committed
854 855
}

856
double Item_sum_avg::val_real()
unknown's avatar
unknown committed
857
{
858
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
859 860 861 862 863
  if (!count)
  {
    null_value=1;
    return 0.0;
  }
unknown's avatar
unknown committed
864 865 866 867 868 869
  return Item_sum_sum::val_real() / ulonglong2double(count);
}


my_decimal *Item_sum_avg::val_decimal(my_decimal *val)
{
870 871
  my_decimal sum, cnt;
  const my_decimal *sum_dec;
unknown's avatar
unknown committed
872 873 874 875 876 877
  DBUG_ASSERT(fixed == 1);
  if (!count)
  {
    null_value=1;
    return NULL;
  }
878
  sum_dec= Item_sum_sum::val_decimal(&sum);
unknown's avatar
unknown committed
879
  int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &cnt);
unknown's avatar
unknown committed
880
  my_decimal_div(E_DEC_FATAL_ERROR, val, sum_dec, &cnt, prec_increment);
unknown's avatar
unknown committed
881 882 883 884 885 886 887
  return val;
}


String *Item_sum_avg::val_str(String *str)
{
  if (hybrid_type == DECIMAL_RESULT)
888 889
    return val_string_from_decimal(str);
  return val_string_from_real(str);
unknown's avatar
unknown committed
890 891 892 893
}


/*
894
  Standard deviation
unknown's avatar
unknown committed
895 896
*/

897
double Item_sum_std::val_real()
unknown's avatar
unknown committed
898
{
899
  DBUG_ASSERT(fixed == 1);
900
  double tmp= Item_sum_variance::val_real();
unknown's avatar
unknown committed
901
  return tmp <= 0.0 ? 0.0 : sqrt(tmp);
unknown's avatar
unknown committed
902 903
}

904 905
Item *Item_sum_std::copy_or_same(THD* thd)
{
unknown's avatar
unknown committed
906
  return new (thd->mem_root) Item_sum_std(thd, this);
907 908 909
}


unknown's avatar
unknown committed
910
/*
911
  Variance
unknown's avatar
unknown committed
912 913
*/

unknown's avatar
unknown committed
914 915 916

Item_sum_variance::Item_sum_variance(THD *thd, Item_sum_variance *item):
  Item_sum_num(thd, item), hybrid_type(item->hybrid_type),
unknown's avatar
unknown committed
917 918
    cur_dec(item->cur_dec), count(item->count), sample(item->sample),
    prec_increment(item->prec_increment)
unknown's avatar
unknown committed
919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939
{
  if (hybrid_type == DECIMAL_RESULT)
  {
    memcpy(dec_sum, item->dec_sum, sizeof(item->dec_sum));
    memcpy(dec_sqr, item->dec_sqr, sizeof(item->dec_sqr));
    for (int i=0; i<2; i++)
    {
      dec_sum[i].fix_buffer_pointer();
      dec_sqr[i].fix_buffer_pointer();
    }
  }
  else
  {
    sum= item->sum;
    sum_sqr= item->sum_sqr;
  }
}


void Item_sum_variance::fix_length_and_dec()
{
940 941
  DBUG_ENTER("Item_sum_variance::fix_length_and_dec");
  maybe_null= null_value= 1;
unknown's avatar
unknown committed
942
  prec_increment= current_thd->variables.div_precincrement;
943
  switch (args[0]->result_type()) {
unknown's avatar
unknown committed
944 945
  case REAL_RESULT:
  case STRING_RESULT:
unknown's avatar
unknown committed
946
    decimals= min(args[0]->decimals + 4, NOT_FIXED_DEC);
unknown's avatar
unknown committed
947 948 949 950 951
    hybrid_type= REAL_RESULT;
    sum= 0.0;
    break;
  case INT_RESULT:
  case DECIMAL_RESULT:
unknown's avatar
unknown committed
952 953 954 955 956
  {
    int precision= args[0]->decimal_precision()*2 + prec_increment;
    decimals= min(args[0]->decimals + prec_increment, DECIMAL_MAX_SCALE);
    max_length= my_decimal_precision_to_length(precision, decimals,
                                               unsigned_flag);
unknown's avatar
unknown committed
957 958 959 960
    cur_dec= 0;
    hybrid_type= DECIMAL_RESULT;
    my_decimal_set_zero(dec_sum);
    my_decimal_set_zero(dec_sqr);
961 962 963 964 965 966

    /*
      The maxium value to usable for variance is DECIMAL_MAX_LENGTH/2
      becasue we need to be able to calculate in dec_bin_size1
      column_value * column_value
    */
unknown's avatar
unknown committed
967
    f_scale0= args[0]->decimals;
unknown's avatar
unknown committed
968 969 970 971 972
    f_precision0= min(args[0]->decimal_precision() + DECIMAL_LONGLONG_DIGITS,
                      DECIMAL_MAX_PRECISION);
    f_scale1= min(args[0]->decimals * 2, DECIMAL_MAX_SCALE);
    f_precision1= min(args[0]->decimal_precision()*2 + DECIMAL_LONGLONG_DIGITS,
                      DECIMAL_MAX_PRECISION);
unknown's avatar
unknown committed
973 974 975
    dec_bin_size0= my_decimal_get_binary_size(f_precision0, f_scale0);
    dec_bin_size1= my_decimal_get_binary_size(f_precision1, f_scale1);
    break;
unknown's avatar
unknown committed
976
  }
unknown's avatar
unknown committed
977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
  case ROW_RESULT:
  default:
    DBUG_ASSERT(0);
  }
  DBUG_PRINT("info", ("Type: %s (%d, %d)",
                      (hybrid_type == REAL_RESULT ? "REAL_RESULT" :
                       hybrid_type == DECIMAL_RESULT ? "DECIMAL_RESULT" :
                       hybrid_type == INT_RESULT ? "INT_RESULT" :
                       "--ILLEGAL!!!--"),
                      max_length,
                      (int)decimals));
  DBUG_VOID_RETURN;
}


992 993
Item *Item_sum_variance::copy_or_same(THD* thd)
{
unknown's avatar
unknown committed
994
  return new (thd->mem_root) Item_sum_variance(thd, this);
995 996 997
}


unknown's avatar
unknown committed
998 999 1000
Field *Item_sum_variance::create_tmp_field(bool group, TABLE *table,
                                           uint convert_blob_len)
{
1001
  if (group)
unknown's avatar
unknown committed
1002
  {
1003 1004 1005 1006 1007 1008 1009 1010 1011
    /*
      We must store both value and counter in the temporary table in one field.
      The easyest way is to do this is to store both value in a string
      and unpack on access.
    */
    return new Field_string(((hybrid_type == DECIMAL_RESULT) ?
                             dec_bin_size0 + dec_bin_size1 :
                             sizeof(double)*2) + sizeof(longlong),
                            0, name, table, &my_charset_bin);
unknown's avatar
unknown committed
1012
  }
1013
  if (hybrid_type == DECIMAL_RESULT)
unknown's avatar
unknown committed
1014 1015
    return new Field_new_decimal(max_length, maybe_null, name, table,
                                 decimals, unsigned_flag);
1016
  return new Field_double(max_length, maybe_null,name,table,decimals);
unknown's avatar
unknown committed
1017 1018 1019
}


1020
void Item_sum_variance::clear()
unknown's avatar
unknown committed
1021
{
unknown's avatar
unknown committed
1022 1023 1024 1025 1026 1027 1028 1029
  if (hybrid_type == DECIMAL_RESULT)
  {
    my_decimal_set_zero(dec_sum);
    my_decimal_set_zero(dec_sqr);
    cur_dec= 0;
  }
  else
    sum=sum_sqr=0.0; 
unknown's avatar
unknown committed
1030 1031 1032 1033
  count=0; 
}

bool Item_sum_variance::add()
unknown's avatar
unknown committed
1034
{
unknown's avatar
unknown committed
1035
  if (hybrid_type == DECIMAL_RESULT)
unknown's avatar
unknown committed
1036
  {
unknown's avatar
unknown committed
1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
    my_decimal dec_buf, *dec= args[0]->val_decimal(&dec_buf);
    my_decimal sqr_buf;
    if (!args[0]->null_value)
    {
      count++;
      int next_dec= cur_dec ^ 1;
      my_decimal_mul(E_DEC_FATAL_ERROR, &sqr_buf, dec, dec);
      my_decimal_add(E_DEC_FATAL_ERROR, dec_sqr+next_dec,
                     dec_sqr+cur_dec, &sqr_buf);
      my_decimal_add(E_DEC_FATAL_ERROR, dec_sum+next_dec,
                     dec_sum+cur_dec, dec);
      cur_dec= next_dec;
    }
  }
  else
  {
    double nr= args[0]->val_real();
    if (!args[0]->null_value)
    {
      sum+=nr;
      sum_sqr+=nr*nr;
      count++;
    }
unknown's avatar
unknown committed
1060 1061 1062 1063
  }
  return 0;
}

1064
double Item_sum_variance::val_real()
unknown's avatar
unknown committed
1065
{
1066
  DBUG_ASSERT(fixed == 1);
1067 1068 1069
  if (hybrid_type == DECIMAL_RESULT)
    return val_real_from_decimal();

1070
  if (count <= sample)
unknown's avatar
unknown committed
1071 1072 1073 1074
  {
    null_value=1;
    return 0.0;
  }
unknown's avatar
unknown committed
1075 1076 1077
  null_value=0;
  /* Avoid problems when the precision isn't good enough */
  double tmp=ulonglong2double(count);
1078
  double tmp2= (sum_sqr - sum*sum/tmp)/(tmp - (double)sample);
unknown's avatar
unknown committed
1079 1080 1081 1082 1083 1084
  return tmp2 <= 0.0 ? 0.0 : tmp2;
}


my_decimal *Item_sum_variance::val_decimal(my_decimal *dec_buf)
{
1085
  my_decimal count_buf, count1_buf, sum_sqr_buf;
unknown's avatar
unknown committed
1086 1087
  DBUG_ASSERT(fixed ==1 );
  if (hybrid_type == REAL_RESULT)
1088 1089
    return val_decimal_from_real(dec_buf);

1090
  if (count <= sample)
unknown's avatar
unknown committed
1091 1092 1093 1094 1095 1096
  {
    null_value= 1;
    return 0;
  }
  null_value= 0;
  int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &count_buf);
1097
  int2my_decimal(E_DEC_FATAL_ERROR, count-sample, 0, &count1_buf);
unknown's avatar
unknown committed
1098 1099
  my_decimal_mul(E_DEC_FATAL_ERROR, &sum_sqr_buf,
                 dec_sum+cur_dec, dec_sum+cur_dec);
unknown's avatar
unknown committed
1100 1101
  my_decimal_div(E_DEC_FATAL_ERROR, dec_buf,
                 &sum_sqr_buf, &count_buf, prec_increment);
unknown's avatar
unknown committed
1102
  my_decimal_sub(E_DEC_FATAL_ERROR, &sum_sqr_buf, dec_sqr+cur_dec, dec_buf);
unknown's avatar
unknown committed
1103 1104
  my_decimal_div(E_DEC_FATAL_ERROR, dec_buf,
                 &sum_sqr_buf, &count1_buf, prec_increment);
unknown's avatar
unknown committed
1105 1106 1107
  return dec_buf;
}

1108

unknown's avatar
unknown committed
1109 1110
void Item_sum_variance::reset_field()
{
1111 1112 1113
  double nr;
  char *res= result_field->ptr;

unknown's avatar
unknown committed
1114 1115
  if (hybrid_type == DECIMAL_RESULT)
  {
1116 1117 1118 1119
    my_decimal value, *arg_dec, *arg2_dec;
    longlong tmp;

    arg_dec= args[0]->val_decimal(&value);
unknown's avatar
unknown committed
1120 1121
    if (args[0]->null_value)
    {
1122 1123
      arg_dec= arg2_dec= &decimal_zero;
      tmp= 0;
unknown's avatar
unknown committed
1124 1125 1126 1127
    }
    else
    {
      my_decimal_mul(E_DEC_FATAL_ERROR, dec_sum, arg_dec, arg_dec);
1128 1129
      arg2_dec= dec_sum;
      tmp= 1;
unknown's avatar
unknown committed
1130
    }
1131 1132 1133 1134 1135 1136
    my_decimal2binary(E_DEC_FATAL_ERROR, arg_dec,
                      res, f_precision0, f_scale0);
    my_decimal2binary(E_DEC_FATAL_ERROR, arg2_dec,
                      res+dec_bin_size0, f_precision1, f_scale1);
    res+= dec_bin_size0 + dec_bin_size1;
    int8store(res,tmp);
unknown's avatar
unknown committed
1137 1138
    return;
  }
1139
  nr= args[0]->val_real();
unknown's avatar
unknown committed
1140 1141 1142 1143 1144

  if (args[0]->null_value)
    bzero(res,sizeof(double)*2+sizeof(longlong));
  else
  {
1145
    longlong tmp;
unknown's avatar
unknown committed
1146 1147 1148
    float8store(res,nr);
    nr*=nr;
    float8store(res+sizeof(double),nr);
1149
    tmp= 1;
unknown's avatar
unknown committed
1150 1151 1152 1153
    int8store(res+sizeof(double)*2,tmp);
  }
}

1154

unknown's avatar
unknown committed
1155
void Item_sum_variance::update_field()
unknown's avatar
unknown committed
1156 1157 1158
{
  longlong field_count;
  char *res=result_field->ptr;
unknown's avatar
unknown committed
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
  if (hybrid_type == DECIMAL_RESULT)
  {
    my_decimal value, *arg_val= args[0]->val_decimal(&value);
    if (!args[0]->null_value)
    {
      binary2my_decimal(E_DEC_FATAL_ERROR, res,
                        dec_sum+1, f_precision0, f_scale0);
      binary2my_decimal(E_DEC_FATAL_ERROR, res+dec_bin_size0,
                        dec_sqr+1, f_precision1, f_scale1);
      field_count= sint8korr(res + (dec_bin_size0 + dec_bin_size1));
      my_decimal_add(E_DEC_FATAL_ERROR, dec_sum, arg_val, dec_sum+1);
      my_decimal_mul(E_DEC_FATAL_ERROR, dec_sum+1, arg_val, arg_val);
      my_decimal_add(E_DEC_FATAL_ERROR, dec_sqr, dec_sqr+1, dec_sum+1);
      field_count++;
      my_decimal2binary(E_DEC_FATAL_ERROR, dec_sum,
                        res, f_precision0, f_scale0);
      my_decimal2binary(E_DEC_FATAL_ERROR, dec_sqr,
                        res+dec_bin_size0, f_precision1, f_scale1);
      res+= dec_bin_size0 + dec_bin_size1;
      int8store(res, field_count);
    }
    return;
  }
unknown's avatar
unknown committed
1182

unknown's avatar
unknown committed
1183
  double nr,old_nr,old_sqr;
unknown's avatar
unknown committed
1184 1185 1186
  float8get(old_nr, res);
  float8get(old_sqr, res+sizeof(double));
  field_count=sint8korr(res+sizeof(double)*2);
unknown's avatar
unknown committed
1187

1188
  nr= args[0]->val_real();
unknown's avatar
unknown committed
1189 1190 1191 1192 1193 1194 1195 1196
  if (!args[0]->null_value)
  {
    old_nr+=nr;
    old_sqr+=nr*nr;
    field_count++;
  }
  float8store(res,old_nr);
  float8store(res+sizeof(double),old_sqr);
1197 1198
  res+= sizeof(double)*2;
  int8store(res,field_count);
unknown's avatar
unknown committed
1199 1200
}

1201

unknown's avatar
unknown committed
1202 1203
/* min & max */

1204 1205
void Item_sum_hybrid::clear()
{
1206
  switch (hybrid_type) {
unknown's avatar
unknown committed
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
  case INT_RESULT:
    sum_int= 0;
    break;
  case DECIMAL_RESULT:
    my_decimal_set_zero(&sum_dec);
    break;
  case REAL_RESULT:
    sum= 0.0;
    break;
  default:
    value.length(0);
  }
1219 1220 1221
  null_value= 1;
}

1222
double Item_sum_hybrid::val_real()
unknown's avatar
unknown committed
1223
{
1224
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1225 1226
  if (null_value)
    return 0.0;
1227 1228
  switch (hybrid_type) {
  case STRING_RESULT:
1229 1230 1231
  {
    char *end_not_used;
    int err_not_used;
unknown's avatar
unknown committed
1232
    String *res;  res=val_str(&str_value);
1233 1234 1235
    return (res ? my_strntod(res->charset(), (char*) res->ptr(), res->length(),
			     &end_not_used, &err_not_used) : 0.0);
  }
1236 1237 1238 1239
  case INT_RESULT:
    if (unsigned_flag)
      return ulonglong2double(sum_int);
    return (double) sum_int;
unknown's avatar
unknown committed
1240 1241 1242
  case DECIMAL_RESULT:
    my_decimal2double(E_DEC_FATAL_ERROR, &sum_dec, &sum);
    return sum;
1243 1244
  case REAL_RESULT:
    return sum;
1245
  case ROW_RESULT:
unknown's avatar
unknown committed
1246
  default:
unknown's avatar
unknown committed
1247 1248 1249
    // This case should never be choosen
    DBUG_ASSERT(0);
    return 0;
unknown's avatar
unknown committed
1250
  }
1251 1252 1253 1254
}

longlong Item_sum_hybrid::val_int()
{
1255
  DBUG_ASSERT(fixed == 1);
1256 1257
  if (null_value)
    return 0;
1258
  switch (hybrid_type) {
unknown's avatar
unknown committed
1259 1260 1261 1262 1263 1264
  case INT_RESULT:
    return sum_int;
  case DECIMAL_RESULT:
  {
    longlong result;
    my_decimal2int(E_DEC_FATAL_ERROR, &sum_dec, unsigned_flag, &result);
1265
    return sum_int;
unknown's avatar
unknown committed
1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297
  }
  default:
    return (longlong) Item_sum_hybrid::val_real();
  }
}


my_decimal *Item_sum_hybrid::val_decimal(my_decimal *val)
{
  DBUG_ASSERT(fixed == 1);
  if (null_value)
    return 0;
  switch (hybrid_type) {
  case STRING_RESULT:
    string2my_decimal(E_DEC_FATAL_ERROR, &value, val);
    break;
  case REAL_RESULT:
    double2my_decimal(E_DEC_FATAL_ERROR, sum, val);
    break;
  case DECIMAL_RESULT:
    val= &sum_dec;
    break;
  case INT_RESULT:
    int2my_decimal(E_DEC_FATAL_ERROR, sum_int, unsigned_flag, val);
    break;
  case ROW_RESULT:
  default:
    // This case should never be choosen
    DBUG_ASSERT(0);
    break;
  }
  return val;					// Keep compiler happy
unknown's avatar
unknown committed
1298 1299 1300 1301 1302 1303
}


String *
Item_sum_hybrid::val_str(String *str)
{
1304
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1305 1306
  if (null_value)
    return 0;
1307 1308
  switch (hybrid_type) {
  case STRING_RESULT:
unknown's avatar
unknown committed
1309
    return &value;
1310
  case REAL_RESULT:
unknown's avatar
unknown committed
1311
    str->set(sum,decimals, &my_charset_bin);
1312
    break;
unknown's avatar
unknown committed
1313 1314 1315
  case DECIMAL_RESULT:
    my_decimal2string(E_DEC_FATAL_ERROR, &sum_dec, 0, 0, 0, str);
    return str;
1316 1317
  case INT_RESULT:
    if (unsigned_flag)
unknown's avatar
unknown committed
1318
      str->set((ulonglong) sum_int, &my_charset_bin);
1319
    else
unknown's avatar
unknown committed
1320
      str->set((longlong) sum_int, &my_charset_bin);
1321
    break;
1322
  case ROW_RESULT:
unknown's avatar
unknown committed
1323
  default:
unknown's avatar
unknown committed
1324 1325 1326
    // This case should never be choosen
    DBUG_ASSERT(0);
    break;
1327 1328
  }
  return str;					// Keep compiler happy
unknown's avatar
unknown committed
1329 1330
}

1331

1332 1333 1334 1335 1336
void Item_sum_hybrid::cleanup()
{
  DBUG_ENTER("Item_sum_hybrid::cleanup");
  Item_sum::cleanup();
  used_table_cache= ~(table_map) 0;
unknown's avatar
unknown committed
1337

1338
  /*
unknown's avatar
unknown committed
1339
    by default it is TRUE to avoid TRUE reporting by
1340 1341 1342
    Item_func_not_all/Item_func_nop_all if this item was never called.

    no_rows_in_result() set it to FALSE if was not results found.
unknown's avatar
unknown committed
1343
    If some results found it will be left unchanged.
1344 1345
  */
  was_values= TRUE;
1346 1347 1348
  DBUG_VOID_RETURN;
}

1349 1350 1351 1352 1353 1354
void Item_sum_hybrid::no_rows_in_result()
{
  Item_sum::no_rows_in_result();
  was_values= FALSE;
}

1355

1356 1357
Item *Item_sum_min::copy_or_same(THD* thd)
{
unknown's avatar
unknown committed
1358
  return new (thd->mem_root) Item_sum_min(thd, this);
1359 1360 1361
}


unknown's avatar
unknown committed
1362 1363
bool Item_sum_min::add()
{
1364 1365
  switch (hybrid_type) {
  case STRING_RESULT:
unknown's avatar
unknown committed
1366 1367 1368
  {
    String *result=args[0]->val_str(&tmp_value);
    if (!args[0]->null_value &&
1369
	(null_value || sortcmp(&value,result,collation.collation) > 0))
unknown's avatar
unknown committed
1370 1371 1372 1373 1374
    {
      value.copy(*result);
      null_value=0;
    }
  }
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
  break;
  case INT_RESULT:
  {
    longlong nr=args[0]->val_int();
    if (!args[0]->null_value && (null_value ||
				 (unsigned_flag && 
				  (ulonglong) nr < (ulonglong) sum_int) ||
				 (!unsigned_flag && nr < sum_int)))
    {
      sum_int=nr;
      null_value=0;
    }
  }
  break;
unknown's avatar
unknown committed
1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
  case DECIMAL_RESULT:
  {
    my_decimal value, *val= args[0]->val_decimal(&value);
    if (!args[0]->null_value &&
        (null_value || (my_decimal_cmp(&sum_dec, val) > 0)))
    {
      my_decimal2decimal(val, &sum_dec);
      null_value= 0;
    }
  }
  break;
1400
  case REAL_RESULT:
unknown's avatar
unknown committed
1401
  {
1402
    double nr= args[0]->val_real();
1403
    if (!args[0]->null_value && (null_value || nr < sum))
unknown's avatar
unknown committed
1404 1405 1406 1407 1408
    {
      sum=nr;
      null_value=0;
    }
  }
1409
  break;
1410
  case ROW_RESULT:
unknown's avatar
unknown committed
1411
  default:
unknown's avatar
unknown committed
1412 1413 1414
    // This case should never be choosen
    DBUG_ASSERT(0);
    break;
1415 1416 1417 1418 1419
  }
  return 0;
}


1420 1421
Item *Item_sum_max::copy_or_same(THD* thd)
{
unknown's avatar
unknown committed
1422
  return new (thd->mem_root) Item_sum_max(thd, this);
1423 1424 1425
}


1426 1427 1428 1429
bool Item_sum_max::add()
{
  switch (hybrid_type) {
  case STRING_RESULT:
unknown's avatar
unknown committed
1430 1431 1432
  {
    String *result=args[0]->val_str(&tmp_value);
    if (!args[0]->null_value &&
1433
	(null_value || sortcmp(&value,result,collation.collation) < 0))
unknown's avatar
unknown committed
1434 1435 1436 1437 1438
    {
      value.copy(*result);
      null_value=0;
    }
  }
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
  break;
  case INT_RESULT:
  {
    longlong nr=args[0]->val_int();
    if (!args[0]->null_value && (null_value ||
				 (unsigned_flag && 
				  (ulonglong) nr > (ulonglong) sum_int) ||
				 (!unsigned_flag && nr > sum_int)))
    {
      sum_int=nr;
      null_value=0;
    }
  }
  break;
unknown's avatar
unknown committed
1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463
  case DECIMAL_RESULT:
  {
    my_decimal value, *val= args[0]->val_decimal(&value);
    if (!args[0]->null_value &&
        (null_value || (my_decimal_cmp(val, &sum_dec) > 0)))
    {
      my_decimal2decimal(val, &sum_dec);
      null_value= 0;
    }
  }
  break;
1464 1465
  case REAL_RESULT:
  {
1466
    double nr= args[0]->val_real();
1467 1468 1469 1470 1471 1472 1473
    if (!args[0]->null_value && (null_value || nr > sum))
    {
      sum=nr;
      null_value=0;
    }
  }
  break;
1474
  case ROW_RESULT:
unknown's avatar
unknown committed
1475
  default:
unknown's avatar
unknown committed
1476 1477 1478
    // This case should never be choosen
    DBUG_ASSERT(0);
    break;
1479
  }
unknown's avatar
unknown committed
1480 1481 1482 1483 1484 1485 1486 1487
  return 0;
}


/* bit_or and bit_and */

longlong Item_sum_bit::val_int()
{
1488
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1489 1490 1491
  return (longlong) bits;
}

1492

1493
void Item_sum_bit::clear()
1494
{
1495
  bits= reset_bits;
1496 1497 1498
}

Item *Item_sum_or::copy_or_same(THD* thd)
unknown's avatar
unknown committed
1499
{
unknown's avatar
unknown committed
1500
  return new (thd->mem_root) Item_sum_or(thd, this);
unknown's avatar
unknown committed
1501 1502
}

1503

unknown's avatar
unknown committed
1504 1505 1506 1507 1508 1509 1510 1511
bool Item_sum_or::add()
{
  ulonglong value= (ulonglong) args[0]->val_int();
  if (!args[0]->null_value)
    bits|=value;
  return 0;
}

1512 1513
Item *Item_sum_xor::copy_or_same(THD* thd)
{
unknown's avatar
unknown committed
1514
  return new (thd->mem_root) Item_sum_xor(thd, this);
1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
}


bool Item_sum_xor::add()
{
  ulonglong value= (ulonglong) args[0]->val_int();
  if (!args[0]->null_value)
    bits^=value;
  return 0;
}

1526 1527
Item *Item_sum_and::copy_or_same(THD* thd)
{
unknown's avatar
unknown committed
1528
  return new (thd->mem_root) Item_sum_and(thd, this);
1529 1530 1531
}


unknown's avatar
unknown committed
1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545
bool Item_sum_and::add()
{
  ulonglong value= (ulonglong) args[0]->val_int();
  if (!args[0]->null_value)
    bits&=value;
  return 0;
}

/************************************************************************
** reset result of a Item_sum with is saved in a tmp_table
*************************************************************************/

void Item_sum_num::reset_field()
{
1546
  double nr= args[0]->val_real();
unknown's avatar
unknown committed
1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
  char *res=result_field->ptr;

  if (maybe_null)
  {
    if (args[0]->null_value)
    {
      nr=0.0;
      result_field->set_null();
    }
    else
      result_field->set_notnull();
  }
  float8store(res,nr);
}


void Item_sum_hybrid::reset_field()
{
1565
  switch(hybrid_type) {
unknown's avatar
unknown committed
1566
  case STRING_RESULT:
unknown's avatar
unknown committed
1567 1568
  {
    char buff[MAX_FIELD_WIDTH];
1569
    String tmp(buff,sizeof(buff),result_field->charset()),*res;
unknown's avatar
unknown committed
1570 1571 1572 1573 1574 1575 1576 1577 1578 1579

    res=args[0]->val_str(&tmp);
    if (args[0]->null_value)
    {
      result_field->set_null();
      result_field->reset();
    }
    else
    {
      result_field->set_notnull();
1580
      result_field->store(res->ptr(),res->length(),tmp.charset());
unknown's avatar
unknown committed
1581
    }
unknown's avatar
unknown committed
1582
    break;
unknown's avatar
unknown committed
1583
  }
unknown's avatar
unknown committed
1584
  case INT_RESULT:
unknown's avatar
unknown committed
1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
  {
    longlong nr=args[0]->val_int();

    if (maybe_null)
    {
      if (args[0]->null_value)
      {
	nr=0;
	result_field->set_null();
      }
      else
	result_field->set_notnull();
    }
    result_field->store(nr);
unknown's avatar
unknown committed
1599
    break;
unknown's avatar
unknown committed
1600
  }
unknown's avatar
unknown committed
1601
  case REAL_RESULT:
unknown's avatar
unknown committed
1602
  {
1603
    double nr= args[0]->val_real();
unknown's avatar
unknown committed
1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615

    if (maybe_null)
    {
      if (args[0]->null_value)
      {
	nr=0.0;
	result_field->set_null();
      }
      else
	result_field->set_notnull();
    }
    result_field->store(nr);
unknown's avatar
unknown committed
1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628
    break;
  }
  case DECIMAL_RESULT:
  {
    my_decimal value, *arg_dec= args[0]->val_decimal(&value);

    if (maybe_null)
    {
      if (args[0]->null_value)
        result_field->set_null();
      else
        result_field->set_notnull();
    }
1629 1630 1631 1632 1633 1634 1635
    /*
      We must store zero in the field as we will use the field value in
      add()
    */
    if (!arg_dec)                               // Null
      arg_dec= &decimal_zero;
    result_field->store_decimal(arg_dec);
unknown's avatar
unknown committed
1636 1637 1638 1639 1640
    break;
  }
  case ROW_RESULT:
  default:
    DBUG_ASSERT(0);
unknown's avatar
unknown committed
1641 1642 1643 1644 1645 1646
  }
}


void Item_sum_sum::reset_field()
{
unknown's avatar
unknown committed
1647 1648 1649
  if (hybrid_type == DECIMAL_RESULT)
  {
    my_decimal value, *arg_val= args[0]->val_decimal(&value);
1650 1651 1652
    if (!arg_val)                               // Null
      arg_val= &decimal_zero;
    result_field->store_decimal(arg_val);
unknown's avatar
unknown committed
1653 1654 1655 1656 1657 1658 1659
  }
  else
  {
    DBUG_ASSERT(hybrid_type == REAL_RESULT);
    double nr= args[0]->val_real();			// Nulls also return 0
    float8store(result_field->ptr, nr);
  }
unknown's avatar
unknown committed
1660 1661 1662 1663
  if (args[0]->null_value)
    result_field->set_null();
  else
    result_field->set_notnull();
unknown's avatar
unknown committed
1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686
}


void Item_sum_count::reset_field()
{
  char *res=result_field->ptr;
  longlong nr=0;

  if (!args[0]->maybe_null)
    nr=1;
  else
  {
    (void) args[0]->val_int();
    if (!args[0]->null_value)
      nr=1;
  }
  int8store(res,nr);
}


void Item_sum_avg::reset_field()
{
  char *res=result_field->ptr;
unknown's avatar
unknown committed
1687 1688
  if (hybrid_type == DECIMAL_RESULT)
  {
1689
    longlong tmp;
unknown's avatar
unknown committed
1690 1691 1692
    my_decimal value, *arg_dec= args[0]->val_decimal(&value);
    if (args[0]->null_value)
    {
1693 1694
      arg_dec= &decimal_zero;
      tmp= 0;
unknown's avatar
unknown committed
1695 1696
    }
    else
1697 1698 1699 1700
      tmp= 1;
    my_decimal2binary(E_DEC_FATAL_ERROR, arg_dec, res, f_precision, f_scale);
    res+= dec_bin_size;
    int8store(res, tmp);
unknown's avatar
unknown committed
1701
  }
unknown's avatar
unknown committed
1702 1703
  else
  {
unknown's avatar
unknown committed
1704 1705 1706 1707 1708 1709
    double nr= args[0]->val_real();

    if (args[0]->null_value)
      bzero(res,sizeof(double)+sizeof(longlong));
    else
    {
1710
      longlong tmp= 1;
unknown's avatar
unknown committed
1711 1712 1713 1714
      float8store(res,nr);
      res+=sizeof(double);
      int8store(res,tmp);
    }
unknown's avatar
unknown committed
1715 1716 1717
  }
}

1718

unknown's avatar
unknown committed
1719
void Item_sum_bit::reset_field()
unknown's avatar
unknown committed
1720
{
1721 1722
  reset();
  int8store(result_field->ptr, bits);
unknown's avatar
unknown committed
1723 1724 1725
}

void Item_sum_bit::update_field()
unknown's avatar
unknown committed
1726 1727
{
  char *res=result_field->ptr;
unknown's avatar
unknown committed
1728 1729 1730
  bits= uint8korr(res);
  add();
  int8store(res, bits);
unknown's avatar
unknown committed
1731 1732
}

1733

unknown's avatar
unknown committed
1734 1735 1736 1737
/*
** calc next value and merge it with field_value
*/

unknown's avatar
unknown committed
1738
void Item_sum_sum::update_field()
unknown's avatar
unknown committed
1739
{
unknown's avatar
unknown committed
1740
  if (hybrid_type == DECIMAL_RESULT)
unknown's avatar
unknown committed
1741
  {
unknown's avatar
unknown committed
1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771
    my_decimal value, *arg_val= args[0]->val_decimal(&value);
    if (!args[0]->null_value)
    {
      if (!result_field->is_null())
      {
        my_decimal field_value,
                   *field_val= result_field->val_decimal(&field_value);
        my_decimal_add(E_DEC_FATAL_ERROR, dec_buffs, arg_val, field_val);
        result_field->store_decimal(dec_buffs);
      }
      else
      {
        result_field->store_decimal(arg_val);
        result_field->set_notnull();
      }
    }
  }
  else
  {
    double old_nr,nr;
    char *res=result_field->ptr;

    float8get(old_nr,res);
    nr= args[0]->val_real();
    if (!args[0]->null_value)
    {
      old_nr+=nr;
      result_field->set_notnull();
    }
    float8store(res,old_nr);
unknown's avatar
unknown committed
1772
  }
unknown's avatar
unknown committed
1773 1774 1775
}


unknown's avatar
unknown committed
1776
void Item_sum_count::update_field()
unknown's avatar
unknown committed
1777 1778 1779 1780
{
  longlong nr;
  char *res=result_field->ptr;

unknown's avatar
unknown committed
1781
  nr=sint8korr(res);
unknown's avatar
unknown committed
1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
  if (!args[0]->maybe_null)
    nr++;
  else
  {
    (void) args[0]->val_int();
    if (!args[0]->null_value)
      nr++;
  }
  int8store(res,nr);
}


unknown's avatar
unknown committed
1794
void Item_sum_avg::update_field()
unknown's avatar
unknown committed
1795 1796 1797
{
  longlong field_count;
  char *res=result_field->ptr;
unknown's avatar
unknown committed
1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809
  if (hybrid_type == DECIMAL_RESULT)
  {
    my_decimal value, *arg_val= args[0]->val_decimal(&value);
    if (!args[0]->null_value)
    {
      binary2my_decimal(E_DEC_FATAL_ERROR, res,
                        dec_buffs + 1, f_precision, f_scale);
      field_count= sint8korr(res + dec_bin_size);
      my_decimal_add(E_DEC_FATAL_ERROR, dec_buffs, arg_val, dec_buffs + 1);
      my_decimal2binary(E_DEC_FATAL_ERROR, dec_buffs,
                        res, f_precision, f_scale);
      res+= dec_bin_size;
1810
      field_count++;
unknown's avatar
unknown committed
1811 1812 1813 1814 1815
      int8store(res, field_count);
    }
  }
  else
  {
1816
    double nr;
unknown's avatar
unknown committed
1817

unknown's avatar
unknown committed
1818 1819 1820
    nr= args[0]->val_real();
    if (!args[0]->null_value)
    {
1821 1822 1823
      double old_nr;
      float8get(old_nr, res);
      field_count= sint8korr(res + sizeof(double));
unknown's avatar
unknown committed
1824
      old_nr+= nr;
1825 1826
      float8store(res,old_nr);
      res+= sizeof(double);
unknown's avatar
unknown committed
1827
      field_count++;
1828
      int8store(res, field_count);
unknown's avatar
unknown committed
1829
    }
unknown's avatar
unknown committed
1830 1831 1832
  }
}

1833

unknown's avatar
unknown committed
1834
void Item_sum_hybrid::update_field()
unknown's avatar
unknown committed
1835
{
1836
  switch (hybrid_type) {
unknown's avatar
unknown committed
1837
  case STRING_RESULT:
unknown's avatar
unknown committed
1838
    min_max_update_str_field();
unknown's avatar
unknown committed
1839 1840
    break;
  case INT_RESULT:
unknown's avatar
unknown committed
1841
    min_max_update_int_field();
unknown's avatar
unknown committed
1842 1843 1844 1845 1846
    break;
  case DECIMAL_RESULT:
    min_max_update_decimal_field();
    break;
  default:
unknown's avatar
unknown committed
1847
    min_max_update_real_field();
unknown's avatar
unknown committed
1848
  }
unknown's avatar
unknown committed
1849 1850 1851 1852
}


void
unknown's avatar
unknown committed
1853
Item_sum_hybrid::min_max_update_str_field()
unknown's avatar
unknown committed
1854 1855 1856
{
  String *res_str=args[0]->val_str(&value);

unknown's avatar
unknown committed
1857
  if (!args[0]->null_value)
unknown's avatar
unknown committed
1858 1859
  {
    res_str->strip_sp();
1860
    result_field->val_str(&tmp_value);
unknown's avatar
unknown committed
1861 1862

    if (result_field->is_null() ||
1863
	(cmp_sign * sortcmp(res_str,&tmp_value,collation.collation)) < 0)
1864
      result_field->store(res_str->ptr(),res_str->length(),res_str->charset());
unknown's avatar
unknown committed
1865 1866 1867 1868 1869 1870
    result_field->set_notnull();
  }
}


void
unknown's avatar
unknown committed
1871
Item_sum_hybrid::min_max_update_real_field()
unknown's avatar
unknown committed
1872 1873 1874 1875
{
  double nr,old_nr;

  old_nr=result_field->val_real();
1876
  nr= args[0]->val_real();
unknown's avatar
unknown committed
1877 1878
  if (!args[0]->null_value)
  {
unknown's avatar
unknown committed
1879
    if (result_field->is_null(0) ||
unknown's avatar
unknown committed
1880 1881 1882 1883
	(cmp_sign > 0 ? old_nr > nr : old_nr < nr))
      old_nr=nr;
    result_field->set_notnull();
  }
unknown's avatar
unknown committed
1884
  else if (result_field->is_null(0))
unknown's avatar
unknown committed
1885 1886 1887 1888 1889 1890
    result_field->set_null();
  result_field->store(old_nr);
}


void
unknown's avatar
unknown committed
1891
Item_sum_hybrid::min_max_update_int_field()
unknown's avatar
unknown committed
1892 1893 1894 1895 1896 1897 1898
{
  longlong nr,old_nr;

  old_nr=result_field->val_int();
  nr=args[0]->val_int();
  if (!args[0]->null_value)
  {
unknown's avatar
unknown committed
1899
    if (result_field->is_null(0))
unknown's avatar
unknown committed
1900
      old_nr=nr;
1901 1902 1903 1904 1905 1906
    else
    {
      bool res=(unsigned_flag ?
		(ulonglong) old_nr > (ulonglong) nr :
		old_nr > nr);
      /* (cmp_sign > 0 && res) || (!(cmp_sign > 0) && !res) */
unknown's avatar
unknown committed
1907
      if ((cmp_sign > 0) ^ (!res))
1908 1909
	old_nr=nr;
    }
unknown's avatar
unknown committed
1910 1911
    result_field->set_notnull();
  }
unknown's avatar
unknown committed
1912
  else if (result_field->is_null(0))
unknown's avatar
unknown committed
1913 1914 1915 1916 1917
    result_field->set_null();
  result_field->store(old_nr);
}


unknown's avatar
unknown committed
1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
void
Item_sum_hybrid::min_max_update_decimal_field()
{
  /* TODO: optimize: do not get result_field in case of args[0] is NULL */
  my_decimal old_val, nr_val;
  const my_decimal *old_nr= result_field->val_decimal(&old_val);
  const my_decimal *nr= args[0]->val_decimal(&nr_val);
  if (!args[0]->null_value)
  {
    if (result_field->is_null(0))
      old_nr=nr;
    else
    {
      bool res= my_decimal_cmp(old_nr, nr) > 0;
      /* (cmp_sign > 0 && res) || (!(cmp_sign > 0) && !res) */
      if ((cmp_sign > 0) ^ (!res))
        old_nr=nr;
    }
    result_field->set_notnull();
  }
  else if (result_field->is_null(0))
    result_field->set_null();
  result_field->store_decimal(old_nr);
}


Item_avg_field::Item_avg_field(Item_result res_type, Item_sum_avg *item)
unknown's avatar
unknown committed
1945 1946 1947
{
  name=item->name;
  decimals=item->decimals;
unknown's avatar
unknown committed
1948 1949
  max_length= item->max_length;
  unsigned_flag= item->unsigned_flag;
unknown's avatar
unknown committed
1950 1951
  field=item->result_field;
  maybe_null=1;
unknown's avatar
unknown committed
1952
  hybrid_type= res_type;
unknown's avatar
unknown committed
1953
  prec_increment= item->prec_increment;
unknown's avatar
unknown committed
1954 1955 1956 1957 1958 1959
  if (hybrid_type == DECIMAL_RESULT)
  {
    f_scale= item->f_scale;
    f_precision= item->f_precision;
    dec_bin_size= item->dec_bin_size;
  }
unknown's avatar
unknown committed
1960 1961
}

1962
double Item_avg_field::val_real()
unknown's avatar
unknown committed
1963
{
1964
  // fix_fields() never calls for this Item
1965 1966 1967 1968
  double nr;
  longlong count;
  char *res;

unknown's avatar
unknown committed
1969
  if (hybrid_type == DECIMAL_RESULT)
1970
    return val_real_from_decimal();
unknown's avatar
unknown committed
1971

1972 1973 1974 1975 1976 1977 1978
  float8get(nr,field->ptr);
  res= (field->ptr+sizeof(double));
  count= sint8korr(res);

  if ((null_value= !count))
    return 0.0;
  return nr/(double) count;
unknown's avatar
unknown committed
1979 1980
}

1981

unknown's avatar
unknown committed
1982 1983
longlong Item_avg_field::val_int()
{
1984
  return (longlong) val_real();
unknown's avatar
unknown committed
1985 1986 1987
}


1988
my_decimal *Item_avg_field::val_decimal(my_decimal *dec_buf)
unknown's avatar
unknown committed
1989 1990
{
  // fix_fields() never calls for this Item
1991 1992 1993
  if (hybrid_type == REAL_RESULT)
    return val_decimal_from_real(dec_buf);

unknown's avatar
unknown committed
1994 1995
  longlong count= sint8korr(field->ptr + dec_bin_size);
  if ((null_value= !count))
1996
    return 0;
unknown's avatar
unknown committed
1997 1998 1999 2000 2001

  my_decimal dec_count, dec_field;
  binary2my_decimal(E_DEC_FATAL_ERROR,
                    field->ptr, &dec_field, f_precision, f_scale);
  int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &dec_count);
unknown's avatar
unknown committed
2002 2003
  my_decimal_div(E_DEC_FATAL_ERROR, dec_buf,
                 &dec_field, &dec_count, prec_increment);
2004
  return dec_buf;
unknown's avatar
unknown committed
2005 2006
}

unknown's avatar
unknown committed
2007

unknown's avatar
unknown committed
2008 2009
String *Item_avg_field::val_str(String *str)
{
2010
  // fix_fields() never calls for this Item
unknown's avatar
unknown committed
2011
  if (hybrid_type == DECIMAL_RESULT)
2012 2013
    return val_string_from_decimal(str);
  return val_string_from_real(str);
unknown's avatar
unknown committed
2014 2015
}

2016

unknown's avatar
unknown committed
2017
Item_std_field::Item_std_field(Item_sum_std *item)
unknown's avatar
unknown committed
2018 2019 2020 2021
  : Item_variance_field(item)
{
}

2022

2023
double Item_std_field::val_real()
unknown's avatar
unknown committed
2024
{
2025
  double nr;
2026
  // fix_fields() never calls for this Item
2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045
  if (hybrid_type == REAL_RESULT)
  {
    /*
      We can't call Item_variance_field::val_real() on a DECIMAL_RESULT
      as this would call Item_std_field::val_decimal() and we would
      calculate sqrt() twice
    */
    nr= Item_variance_field::val_real();
  }
  else
  {
    my_decimal dec_buf,*dec;
    dec= Item_variance_field::val_decimal(&dec_buf);
    if (!dec)
      nr= 0.0;                                  // NULL; Return 0.0
    else
      my_decimal2double(E_DEC_FATAL_ERROR, dec, &nr);
  }
  return nr <= 0.0 ? 0.0 : sqrt(nr);
unknown's avatar
unknown committed
2046 2047
}

2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069

my_decimal *Item_std_field::val_decimal(my_decimal *dec_buf)
{
  /*
    We can't call val_decimal_from_real() for DECIMAL_RESULT as
    Item_variance_field::val_real() would cause an infinite loop
  */
  my_decimal tmp_dec, *dec;
  double nr;
  if (hybrid_type == REAL_RESULT)
    return val_decimal_from_real(dec_buf);
  dec= Item_variance_field::val_decimal(dec_buf);
  if (!dec)
    return 0;
  my_decimal2double(E_DEC_FATAL_ERROR, dec, &nr);
  nr= nr <= 0.0 ? 0.0 : sqrt(nr);
  double2my_decimal(E_DEC_FATAL_ERROR, nr, &tmp_dec);
  my_decimal_round(E_DEC_FATAL_ERROR, &tmp_dec, decimals, FALSE, dec_buf);
  return dec_buf;
}


unknown's avatar
unknown committed
2070
Item_variance_field::Item_variance_field(Item_sum_variance *item)
unknown's avatar
unknown committed
2071 2072 2073 2074
{
  name=item->name;
  decimals=item->decimals;
  max_length=item->max_length;
unknown's avatar
unknown committed
2075
  unsigned_flag= item->unsigned_flag;
unknown's avatar
unknown committed
2076 2077
  field=item->result_field;
  maybe_null=1;
2078
  sample= item->sample;
unknown's avatar
unknown committed
2079
  prec_increment= item->prec_increment;
unknown's avatar
unknown committed
2080 2081 2082 2083 2084 2085 2086 2087 2088
  if ((hybrid_type= item->hybrid_type) == DECIMAL_RESULT)
  {
    f_scale0= item->f_scale0;
    f_precision0= item->f_precision0;
    dec_bin_size0= item->dec_bin_size0;
    f_scale1= item->f_scale1;
    f_precision1= item->f_precision1;
    dec_bin_size1= item->dec_bin_size1;
  }
unknown's avatar
unknown committed
2089 2090
}

2091

2092
double Item_variance_field::val_real()
unknown's avatar
unknown committed
2093
{
2094
  // fix_fields() never calls for this Item
unknown's avatar
unknown committed
2095
  if (hybrid_type == DECIMAL_RESULT)
2096 2097
    return val_real_from_decimal();

unknown's avatar
unknown committed
2098 2099 2100 2101 2102 2103
  double sum,sum_sqr;
  longlong count;
  float8get(sum,field->ptr);
  float8get(sum_sqr,(field->ptr+sizeof(double)));
  count=sint8korr(field->ptr+sizeof(double)*2);

2104
  if ((null_value= (count <= sample)))
unknown's avatar
unknown committed
2105
    return 0.0;
2106

unknown's avatar
unknown committed
2107
  double tmp= (double) count;
2108
  double tmp2= (sum_sqr - sum*sum/tmp)/(tmp - (double)sample);
unknown's avatar
unknown committed
2109
  return tmp2 <= 0.0 ? 0.0 : tmp2;
unknown's avatar
unknown committed
2110 2111
}

2112

unknown's avatar
unknown committed
2113
String *Item_variance_field::val_str(String *str)
unknown's avatar
unknown committed
2114
{
2115 2116 2117
  if (hybrid_type == DECIMAL_RESULT)
    return val_string_from_decimal(str);
  return val_string_from_real(str);
unknown's avatar
unknown committed
2118 2119
}

unknown's avatar
unknown committed
2120 2121 2122 2123

my_decimal *Item_variance_field::val_decimal(my_decimal *dec_buf)
{
  // fix_fields() never calls for this Item
2124 2125 2126
  if (hybrid_type == REAL_RESULT)
    return val_decimal_from_real(dec_buf);

unknown's avatar
unknown committed
2127
  longlong count= sint8korr(field->ptr+dec_bin_size0+dec_bin_size1);
2128
  if ((null_value= (count <= sample)))
unknown's avatar
unknown committed
2129 2130
    return 0;

2131
  my_decimal dec_count, dec1_count, dec_sum, dec_sqr, tmp;
unknown's avatar
unknown committed
2132
  int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &dec_count);
2133
  int2my_decimal(E_DEC_FATAL_ERROR, count-sample, 0, &dec1_count);
unknown's avatar
unknown committed
2134 2135 2136 2137 2138
  binary2my_decimal(E_DEC_FATAL_ERROR, field->ptr,
                    &dec_sum, f_precision0, f_scale0);
  binary2my_decimal(E_DEC_FATAL_ERROR, field->ptr+dec_bin_size0,
                    &dec_sqr, f_precision1, f_scale1);
  my_decimal_mul(E_DEC_FATAL_ERROR, &tmp, &dec_sum, &dec_sum);
unknown's avatar
unknown committed
2139
  my_decimal_div(E_DEC_FATAL_ERROR, dec_buf, &tmp, &dec_count, prec_increment);
unknown's avatar
unknown committed
2140
  my_decimal_sub(E_DEC_FATAL_ERROR, &dec_sum, &dec_sqr, dec_buf);
unknown's avatar
unknown committed
2141 2142
  my_decimal_div(E_DEC_FATAL_ERROR, dec_buf,
                 &dec_sum, &dec1_count, prec_increment);
unknown's avatar
unknown committed
2143 2144 2145 2146
  return dec_buf;
}


unknown's avatar
unknown committed
2147 2148 2149 2150
/****************************************************************************
** COUNT(DISTINCT ...)
****************************************************************************/

2151
int simple_str_key_cmp(void* arg, byte* key1, byte* key2)
2152
{
2153
  Field *f= (Field*) arg;
unknown's avatar
unknown committed
2154
  return f->cmp((const char*)key1, (const char*)key2);
2155 2156
}

unknown's avatar
unknown committed
2157 2158 2159 2160 2161 2162 2163
/*
  Did not make this one static - at least gcc gets confused when
  I try to declare a static function as a friend. If you can figure
  out the syntax to make a static function a friend, make this one
  static
*/

2164 2165 2166
int composite_key_cmp(void* arg, byte* key1, byte* key2)
{
  Item_sum_count_distinct* item = (Item_sum_count_distinct*)arg;
unknown's avatar
unknown committed
2167
  Field **field    = item->table->field;
2168
  Field **field_end= field + item->table->s->fields;
unknown's avatar
unknown committed
2169 2170 2171 2172 2173
  uint32 *lengths=item->field_lengths;
  for (; field < field_end; ++field)
  {
    Field* f = *field;
    int len = *lengths++;
unknown's avatar
unknown committed
2174
    int res = f->cmp((char *) key1, (char *) key2);
unknown's avatar
unknown committed
2175 2176 2177 2178 2179
    if (res)
      return res;
    key1 += len;
    key2 += len;
  }
2180 2181 2182 2183
  return 0;
}


2184 2185
C_MODE_START

2186
static int count_distinct_walk(void *elem, element_count count, void *arg)
2187
{
2188
  (*((ulonglong*)arg))++;
2189 2190
  return 0;
}
2191

2192 2193
C_MODE_END

unknown's avatar
unknown committed
2194

unknown's avatar
unknown committed
2195
void Item_sum_count_distinct::cleanup()
unknown's avatar
unknown committed
2196
{
unknown's avatar
unknown committed
2197
  DBUG_ENTER("Item_sum_count_distinct::cleanup");
unknown's avatar
unknown committed
2198
  Item_sum_int::cleanup();
2199 2200

  /* Free objects only if we own them. */
2201 2202
  if (!original)
  {
2203 2204 2205 2206 2207 2208 2209
    /*
      We need to delete the table and the tree in cleanup() as
      they were allocated in the runtime memroot. Using the runtime
      memroot reduces memory footprint for PS/SP and simplifies setup().
    */
    delete tree;
    tree= 0;
2210
    if (table)
unknown's avatar
unknown committed
2211
    {
2212
      free_tmp_table(table->in_use, table);
unknown's avatar
unknown committed
2213 2214
      table= 0;
    }
2215
    delete tmp_table_param;
unknown's avatar
unknown committed
2216
    tmp_table_param= 0;
2217
  }
2218
  always_null= FALSE;
unknown's avatar
unknown committed
2219
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2220 2221
}

unknown's avatar
unknown committed
2222

2223 2224 2225 2226 2227 2228
/* This is used by rollup to create a separate usable copy of the function */

void Item_sum_count_distinct::make_unique()
{
  table=0;
  original= 0;
2229 2230 2231 2232 2233 2234 2235 2236 2237
  tree= 0;
  tmp_table_param= 0;
  always_null= FALSE;
}


Item_sum_count_distinct::~Item_sum_count_distinct()
{
  cleanup();
2238 2239 2240
}


unknown's avatar
unknown committed
2241 2242 2243
bool Item_sum_count_distinct::setup(THD *thd)
{
  List<Item> list;
unknown's avatar
unknown committed
2244
  SELECT_LEX *select_lex= thd->lex->current_select;
2245 2246 2247 2248 2249 2250 2251 2252

  /*
    Setup can be called twice for ROLLUP items. This is a bug.
    Please add DBUG_ASSERT(tree == 0) here when it's fixed.
  */
  if (tree || table || tmp_table_param)
    return FALSE;

2253
  if (!(tmp_table_param= new TMP_TABLE_PARAM))
unknown's avatar
unknown committed
2254
    return TRUE;
2255

unknown's avatar
unknown committed
2256 2257
  /* Create a table with an unique key over all parameters */
  for (uint i=0; i < arg_count ; i++)
2258 2259 2260
  {
    Item *item=args[i];
    if (list.push_back(item))
unknown's avatar
unknown committed
2261
      return TRUE;                              // End of memory
2262 2263 2264 2265 2266 2267 2268 2269
    if (item->const_item())
    {
      (void) item->val_int();
      if (item->null_value)
	always_null=1;
    }
  }
  if (always_null)
unknown's avatar
unknown committed
2270
    return FALSE;
unknown's avatar
unknown committed
2271
  count_field_types(tmp_table_param,list,0);
2272
  DBUG_ASSERT(table == 0);
2273
  if (!(table= create_tmp_table(thd, tmp_table_param, list, (ORDER*) 0, 1,
unknown's avatar
unknown committed
2274
				0,
2275
				select_lex->options | thd->options,
2276
				HA_POS_ERROR, (char*)"")))
unknown's avatar
unknown committed
2277
    return TRUE;
unknown's avatar
unknown committed
2278
  table->file->extra(HA_EXTRA_NO_ROWS);		// Don't update rows
2279
  table->no_rows=1;
2280

2281
  if (table->s->db_type == DB_TYPE_HEAP)
unknown's avatar
unknown committed
2282
  {
2283 2284 2285 2286
    /*
      No blobs, otherwise it would have been MyISAM: set up a compare
      function and its arguments to use with Unique.
    */
unknown's avatar
unknown committed
2287 2288
    qsort_cmp2 compare_key;
    void* cmp_arg;
2289 2290 2291
    Field **field= table->field;
    Field **field_end= field + table->s->fields;
    bool all_binary= TRUE;
unknown's avatar
unknown committed
2292

2293
    for (tree_key_length= 0; field < field_end; ++field)
unknown's avatar
unknown committed
2294
    {
2295 2296 2297 2298 2299 2300 2301 2302 2303
      Field *f= *field;
      enum enum_field_types type= f->type();
      tree_key_length+= f->pack_length();
      if (!f->binary() && (type == MYSQL_TYPE_STRING ||
                           type == MYSQL_TYPE_VAR_STRING ||
                           type == MYSQL_TYPE_VARCHAR))
      {
        all_binary= FALSE;
        break;
unknown's avatar
unknown committed
2304
      }
2305
    }
2306
    if (all_binary)
unknown's avatar
unknown committed
2307
    {
2308 2309 2310 2311 2312 2313
      cmp_arg= (void*) &tree_key_length;
      compare_key= (qsort_cmp2) simple_raw_key_cmp;
    }
    else
    {
      if (table->s->fields == 1)
unknown's avatar
unknown committed
2314
      {
2315 2316 2317 2318 2319 2320 2321 2322 2323
        /*
          If we have only one field, which is the most common use of
          count(distinct), it is much faster to use a simpler key
          compare method that can take advantage of not having to worry
          about other fields.
        */
        compare_key= (qsort_cmp2) simple_str_key_cmp;
        cmp_arg= (void*) table->field[0];
        /* tree_key_length has been set already */
unknown's avatar
unknown committed
2324 2325 2326
      }
      else
      {
2327 2328 2329 2330 2331 2332 2333 2334 2335 2336
        uint32 *length;
        compare_key= (qsort_cmp2) composite_key_cmp;
        cmp_arg= (void*) this;
        field_lengths= (uint32*) thd->alloc(table->s->fields * sizeof(uint32));
        for (tree_key_length= 0, length= field_lengths, field= table->field;
             field < field_end; ++field, ++length)
        {
          *length= (*field)->pack_length();
          tree_key_length+= *length;
        }
unknown's avatar
unknown committed
2337 2338
      }
    }
2339 2340 2341
    DBUG_ASSERT(tree == 0);
    tree= new Unique(compare_key, cmp_arg, tree_key_length,
                     thd->variables.max_heap_table_size);
unknown's avatar
unknown committed
2342
    /*
2343
      The only time tree_key_length could be 0 is if someone does
unknown's avatar
unknown committed
2344 2345 2346 2347
      count(distinct) on a char(0) field - stupid thing to do,
      but this has to be handled - otherwise someone can crash
      the server with a DoS attack
    */
2348 2349
    if (! tree)
      return TRUE;
unknown's avatar
unknown committed
2350
  }
2351
  return FALSE;
2352
}
unknown's avatar
unknown committed
2353

2354 2355 2356

Item *Item_sum_count_distinct::copy_or_same(THD* thd) 
{
unknown's avatar
unknown committed
2357
  return new (thd->mem_root) Item_sum_count_distinct(thd, this);
2358 2359 2360
}


2361
void Item_sum_count_distinct::clear()
unknown's avatar
unknown committed
2362
{
2363 2364 2365
  /* tree and table can be both null only if always_null */
  if (tree)
    tree->reset();
unknown's avatar
merge  
unknown committed
2366
  else if (table)
2367 2368 2369 2370 2371
  {
    table->file->extra(HA_EXTRA_NO_CACHE);
    table->file->delete_all_rows();
    table->file->extra(HA_EXTRA_WRITE_CACHE);
  }
unknown's avatar
unknown committed
2372 2373 2374 2375 2376
}

bool Item_sum_count_distinct::add()
{
  int error;
2377 2378
  if (always_null)
    return 0;
unknown's avatar
unknown committed
2379
  copy_fields(tmp_table_param);
unknown's avatar
unknown committed
2380
  copy_funcs(tmp_table_param->items_to_copy);
unknown's avatar
unknown committed
2381

2382 2383 2384 2385
  for (Field **field=table->field ; *field ; field++)
    if ((*field)->is_real_null(0))
      return 0;					// Don't count NULL

2386
  if (tree)
unknown's avatar
unknown committed
2387 2388
  {
    /*
2389 2390 2391 2392
      The first few bytes of record (at least one) are just markers
      for deleted and NULLs. We want to skip them since they will
      bloat the tree without providing any valuable info. Besides,
      key_length used to initialize the tree didn't include space for them.
unknown's avatar
unknown committed
2393
    */
2394
    return tree->unique_add(table->record[0] + table->s->null_bytes);
unknown's avatar
unknown committed
2395
  }
2396 2397 2398 2399 2400
  if ((error= table->file->write_row(table->record[0])) &&
      error != HA_ERR_FOUND_DUPP_KEY &&
      error != HA_ERR_FOUND_DUPP_UNIQUE)
    return TRUE;
  return FALSE;
unknown's avatar
unknown committed
2401 2402
}

unknown's avatar
unknown committed
2403

unknown's avatar
unknown committed
2404 2405
longlong Item_sum_count_distinct::val_int()
{
2406
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2407 2408
  if (!table)					// Empty query
    return LL(0);
2409 2410 2411 2412 2413 2414 2415 2416 2417 2418
  if (tree)
  {
    ulonglong count;

    if (tree->elements == 0)
      return (longlong) tree->elements_in_tree(); // everything fits in memory
    count= 0;
    tree->walk(count_distinct_walk, (void*) &count);
    return (longlong) count;
  }
unknown's avatar
unknown committed
2419 2420 2421 2422
  table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
  return table->file->records;
}

2423 2424 2425

void Item_sum_count_distinct::print(String *str)
{
2426
  str->append("count(distinct ", 15);
2427 2428 2429 2430
  args[0]->print(str);
  str->append(')');
}

unknown's avatar
unknown committed
2431 2432 2433 2434 2435 2436 2437 2438 2439
/****************************************************************************
** Functions to handle dynamic loadable aggregates
** Original source by: Alexis Mikhailov <root@medinf.chuvashia.su>
** Adapted for UDAs by: Andreas F. Bobak <bobak@relog.ch>.
** Rewritten by: Monty.
****************************************************************************/

#ifdef HAVE_DLOPEN

2440
void Item_udf_sum::clear()
unknown's avatar
unknown committed
2441
{
2442
  DBUG_ENTER("Item_udf_sum::clear");
2443
  udf.clear();
2444
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2445 2446 2447 2448
}

bool Item_udf_sum::add()
{
2449
  DBUG_ENTER("Item_udf_sum::add");
unknown's avatar
unknown committed
2450 2451 2452 2453
  udf.add(&null_value);
  DBUG_RETURN(0);
}

2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464
void Item_udf_sum::cleanup()
{
  /*
    udf_handler::cleanup() nicely handles case when we have not
    original item but one created by copy_or_same() method.
  */
  udf.cleanup();
  Item_sum::cleanup();
}


2465 2466
Item *Item_sum_udf_float::copy_or_same(THD* thd)
{
unknown's avatar
unknown committed
2467
  return new (thd->mem_root) Item_sum_udf_float(thd, this);
2468 2469
}

2470
double Item_sum_udf_float::val_real()
unknown's avatar
unknown committed
2471
{
2472
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2473 2474 2475 2476 2477 2478
  DBUG_ENTER("Item_sum_udf_float::val");
  DBUG_PRINT("info",("result_type: %d  arg_count: %d",
		     args[0]->result_type(), arg_count));
  DBUG_RETURN(udf.val(&null_value));
}

2479

unknown's avatar
unknown committed
2480 2481
String *Item_sum_udf_float::val_str(String *str)
{
2482
  return val_string_from_real(str);
unknown's avatar
unknown committed
2483 2484 2485
}


2486
my_decimal *Item_sum_udf_float::val_decimal(my_decimal *dec)
2487
{
2488
  return val_decimal_from_real(dec);
2489 2490 2491
}


unknown's avatar
unknown committed
2492 2493
String *Item_sum_udf_decimal::val_str(String *str)
{
2494
  return val_string_from_decimal(str);
unknown's avatar
unknown committed
2495 2496 2497 2498 2499
}


double Item_sum_udf_decimal::val_real()
{
2500
  return val_real_from_decimal();
unknown's avatar
unknown committed
2501 2502 2503 2504 2505
}


longlong Item_sum_udf_decimal::val_int()
{
2506
  return val_int_from_decimal();
unknown's avatar
unknown committed
2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526
}


my_decimal *Item_sum_udf_decimal::val_decimal(my_decimal *dec_buf)
{
  DBUG_ASSERT(fixed == 1);
  DBUG_ENTER("Item_func_udf_decimal::val_decimal");
  DBUG_PRINT("info",("result_type: %d  arg_count: %d",
                     args[0]->result_type(), arg_count));

  DBUG_RETURN(udf.val_decimal(&null_value, dec_buf));
}


Item *Item_sum_udf_decimal::copy_or_same(THD* thd)
{
  return new (thd->mem_root) Item_sum_udf_decimal(thd, this);
}


2527 2528 2529 2530 2531
Item *Item_sum_udf_int::copy_or_same(THD* thd)
{
  return new (thd->mem_root) Item_sum_udf_int(thd, this);
}

unknown's avatar
unknown committed
2532 2533
longlong Item_sum_udf_int::val_int()
{
2534
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2535 2536 2537 2538 2539 2540
  DBUG_ENTER("Item_sum_udf_int::val_int");
  DBUG_PRINT("info",("result_type: %d  arg_count: %d",
		     args[0]->result_type(), arg_count));
  DBUG_RETURN(udf.val_int(&null_value));
}

2541

unknown's avatar
unknown committed
2542 2543
String *Item_sum_udf_int::val_str(String *str)
{
2544
  return val_string_from_int(str);
unknown's avatar
unknown committed
2545 2546
}

2547 2548 2549 2550 2551 2552
my_decimal *Item_sum_udf_int::val_decimal(my_decimal *dec)
{
  return val_decimal_from_int(dec);
}


unknown's avatar
unknown committed
2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563
/* Default max_length is max argument length */

void Item_sum_udf_str::fix_length_and_dec()
{
  DBUG_ENTER("Item_sum_udf_str::fix_length_and_dec");
  max_length=0;
  for (uint i = 0; i < arg_count; i++)
    set_if_bigger(max_length,args[i]->max_length);
  DBUG_VOID_RETURN;
}

2564 2565 2566

Item *Item_sum_udf_str::copy_or_same(THD* thd)
{
unknown's avatar
unknown committed
2567
  return new (thd->mem_root) Item_sum_udf_str(thd, this);
2568 2569 2570
}


2571 2572 2573 2574 2575
my_decimal *Item_sum_udf_str::val_decimal(my_decimal *dec)
{
  return val_decimal_from_string(dec);
}

unknown's avatar
unknown committed
2576 2577
String *Item_sum_udf_str::val_str(String *str)
{
2578
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2579 2580 2581 2582 2583 2584 2585
  DBUG_ENTER("Item_sum_udf_str::str");
  String *res=udf.val_str(str,&str_value);
  null_value = !res;
  DBUG_RETURN(res);
}

#endif /* HAVE_DLOPEN */
2586 2587 2588 2589


/*****************************************************************************
 GROUP_CONCAT function
unknown's avatar
unknown committed
2590 2591

 SQL SYNTAX:
unknown's avatar
unknown committed
2592
  GROUP_CONCAT([DISTINCT] expr,... [ORDER BY col [ASC|DESC],...]
unknown's avatar
unknown committed
2593 2594
    [SEPARATOR str_const])

2595
 concat of values from "group by" operation
unknown's avatar
unknown committed
2596 2597 2598 2599 2600

 BUGS
   DISTINCT and ORDER BY only works if ORDER BY uses all fields and only fields
   in expression list
   Blobs doesn't work with DISTINCT or ORDER BY
2601 2602 2603
*****************************************************************************/

/*
unknown's avatar
SCRUM  
unknown committed
2604 2605
  function of sort for syntax:
  GROUP_CONCAT(DISTINCT expr,...)
2606 2607
*/

unknown's avatar
unknown committed
2608 2609
int group_concat_key_cmp_with_distinct(void* arg, byte* key1,
				       byte* key2)
2610
{
unknown's avatar
unknown committed
2611
  Item_func_group_concat* grp_item= (Item_func_group_concat*)arg;
unknown's avatar
unknown committed
2612
  TABLE *table= grp_item->table;
unknown's avatar
unknown committed
2613
  Item **field_item, **end;
unknown's avatar
unknown committed
2614
  char *record= (char*) table->record[0] + table->s->null_bytes;
unknown's avatar
unknown committed
2615

unknown's avatar
unknown committed
2616
  for (field_item= grp_item->args, end= field_item + grp_item->arg_count_field;
unknown's avatar
unknown committed
2617 2618
       field_item < end;
       field_item++)
2619
  {
unknown's avatar
unknown committed
2620 2621 2622 2623 2624 2625
    /*
      We have to use get_tmp_table_field() instead of
      real_item()->get_tmp_table_field() because we want the field in
      the temporary table, not the original field
    */
    Field *field= (*field_item)->get_tmp_table_field();
2626 2627
    if (field)
    {
unknown's avatar
unknown committed
2628
      int res;
unknown's avatar
unknown committed
2629
      uint offset= (uint) (field->ptr - record);
unknown's avatar
unknown committed
2630
      if ((res= field->cmp((char *) key1 + offset, (char *) key2 + offset)))
unknown's avatar
unknown committed
2631
	return res;
2632
    }
unknown's avatar
unknown committed
2633
  }
2634 2635 2636
  return 0;
}

2637

2638
/*
unknown's avatar
SCRUM  
unknown committed
2639 2640
  function of sort for syntax:
  GROUP_CONCAT(expr,... ORDER BY col,... )
2641 2642
*/

unknown's avatar
unknown committed
2643
int group_concat_key_cmp_with_order(void* arg, byte* key1, byte* key2)
2644
{
unknown's avatar
unknown committed
2645
  Item_func_group_concat* grp_item= (Item_func_group_concat*) arg;
unknown's avatar
unknown committed
2646
  ORDER **order_item, **end;
unknown's avatar
unknown committed
2647 2648
  TABLE *table= grp_item->table;
  char *record= (char*) table->record[0] + table->s->null_bytes;
unknown's avatar
unknown committed
2649

unknown's avatar
unknown committed
2650
  for (order_item= grp_item->order, end=order_item+ grp_item->arg_count_order;
unknown's avatar
unknown committed
2651 2652
       order_item < end;
       order_item++)
2653
  {
unknown's avatar
unknown committed
2654
    Item *item= *(*order_item)->item;
unknown's avatar
unknown committed
2655 2656 2657 2658 2659 2660
    /*
      We have to use get_tmp_table_field() instead of
      real_item()->get_tmp_table_field() because we want the field in
      the temporary table, not the original field
    */
    Field *field= item->get_tmp_table_field();
unknown's avatar
unknown committed
2661
    /* If the item is a constant, there is no tmp table field */
2662 2663
    if (field)
    {
unknown's avatar
unknown committed
2664 2665
      int res;
      uint offset= (uint) (field->ptr - record);
unknown's avatar
unknown committed
2666
      if ((res= field->cmp((char *) key1 + offset, (char *) key2 + offset)))
unknown's avatar
unknown committed
2667
        return (*order_item)->asc ? res : -res;
2668
    }
unknown's avatar
unknown committed
2669
  }
unknown's avatar
SCRUM  
unknown committed
2670
  /*
unknown's avatar
unknown committed
2671 2672
    We can't return 0 because in that case the tree class would remove this
    item as double value. This would cause problems for case-changes and
unknown's avatar
unknown committed
2673
    if the returned values are not the same we do the sort on.
unknown's avatar
unknown committed
2674
  */
2675 2676 2677
  return 1;
}

2678

2679
/*
unknown's avatar
SCRUM  
unknown committed
2680 2681
  function of sort for syntax:
  GROUP_CONCAT(DISTINCT expr,... ORDER BY col,... )
unknown's avatar
unknown committed
2682 2683 2684 2685 2686

  BUG:
    This doesn't work in the case when the order by contains data that
    is not part of the field list because tree-insert will not notice
    the duplicated values when inserting things sorted by ORDER BY
2687
*/
unknown's avatar
SCRUM  
unknown committed
2688

unknown's avatar
unknown committed
2689 2690
int group_concat_key_cmp_with_distinct_and_order(void* arg,byte* key1,
						 byte* key2)
2691 2692 2693 2694 2695 2696
{
  if (!group_concat_key_cmp_with_distinct(arg,key1,key2))
    return 0;
  return(group_concat_key_cmp_with_order(arg,key1,key2));
}

2697

2698
/*
unknown's avatar
unknown committed
2699
  Append data from current leaf to item->result
2700
*/
unknown's avatar
SCRUM  
unknown committed
2701

2702
int dump_leaf_key(byte* key, element_count count __attribute__((unused)),
unknown's avatar
unknown committed
2703
                  Item_func_group_concat *item)
2704
{
unknown's avatar
unknown committed
2705 2706
  TABLE *table= item->table;
  char *record= (char*) table->record[0] + table->s->null_bytes;
2707
  String tmp((char *)table->record[1], table->s->reclength, default_charset_info), tmp2;
unknown's avatar
unknown committed
2708
  String *result= &item->result;
unknown's avatar
unknown committed
2709
  Item **arg= item->args, **arg_end= item->args + item->arg_count_field;
unknown's avatar
unknown committed
2710

unknown's avatar
unknown committed
2711 2712
  if (result->length())
    result->append(*item->separator);
unknown's avatar
a fix  
unknown committed
2713

2714
  tmp.length(0);
unknown's avatar
unknown committed
2715 2716

  for (; arg < arg_end; arg++)
2717
  {
unknown's avatar
unknown committed
2718 2719
    String *res;
    if (! (*arg)->const_item())
2720
    {
unknown's avatar
unknown committed
2721 2722 2723 2724
      /*
	We have to use get_tmp_table_field() instead of
	real_item()->get_tmp_table_field() because we want the field in
	the temporary table, not the original field
unknown's avatar
unknown committed
2725 2726
        We also can't use table->field array to access the fields
        because it contains both order and arg list fields.
unknown's avatar
unknown committed
2727
      */
unknown's avatar
unknown committed
2728
      Field *field= (*arg)->get_tmp_table_field();
unknown's avatar
unknown committed
2729 2730
      char *save_ptr= field->ptr;
      uint offset= (uint) (save_ptr - record);
unknown's avatar
unknown committed
2731
      DBUG_ASSERT(offset < table->s->reclength);
unknown's avatar
unknown committed
2732 2733 2734
      field->ptr= (char *) key + offset;
      res= field->val_str(&tmp,&tmp2);
      field->ptr= save_ptr;
2735
    }
unknown's avatar
unknown committed
2736 2737 2738
    else
      res= (*arg)->val_str(&tmp);
    if (res)
unknown's avatar
unknown committed
2739
      result->append(*res);
2740
  }
unknown's avatar
unknown committed
2741

unknown's avatar
unknown committed
2742
  /* stop if length of result more than max_length */
unknown's avatar
unknown committed
2743
  if (result->length() > item->max_length)
2744
  {
unknown's avatar
unknown committed
2745
    item->count_cut_values++;
unknown's avatar
unknown committed
2746
    result->length(item->max_length);
unknown's avatar
unknown committed
2747
    item->warning_for_row= TRUE;
2748 2749 2750 2751 2752
    return 1;
  }
  return 0;
}

2753

2754
/*
unknown's avatar
SCRUM  
unknown committed
2755
  Constructor of Item_func_group_concat
unknown's avatar
unknown committed
2756 2757 2758 2759
  distinct_arg - distinct
  select_list - list of expression for show values
  order_list - list of sort columns
  separator_arg - string value of separator
2760
*/
unknown's avatar
SCRUM  
unknown committed
2761

unknown's avatar
unknown committed
2762 2763 2764 2765 2766
Item_func_group_concat::
Item_func_group_concat(bool distinct_arg, List<Item> *select_list,
                       SQL_LIST *order_list, String *separator_arg)
  :tmp_table_param(0), warning(0),
   separator(separator_arg), tree(0), table(0),
2767
   order(0), tables_list(0),
unknown's avatar
unknown committed
2768 2769 2770 2771 2772 2773
   arg_count_order(order_list ? order_list->elements : 0),
   arg_count_field(select_list->elements),
   count_cut_values(0),
   distinct(distinct_arg),
   warning_for_row(FALSE),
   original(0)
2774
{
unknown's avatar
unknown committed
2775 2776 2777
  Item *item_select;
  Item **arg_ptr;

unknown's avatar
unknown committed
2778
  quick_group= FALSE;
unknown's avatar
unknown committed
2779
  arg_count= arg_count_field + arg_count_order;
unknown's avatar
unknown committed
2780

unknown's avatar
SCRUM  
unknown committed
2781 2782
  /*
    We need to allocate:
unknown's avatar
unknown committed
2783 2784
    args - arg_count_field+arg_count_order
           (for possible order items in temporare tables)
unknown's avatar
SCRUM  
unknown committed
2785 2786
    order - arg_count_order
  */
unknown's avatar
unknown committed
2787
  if (!(args= (Item**) sql_alloc(sizeof(Item*) * arg_count +
unknown's avatar
unknown committed
2788
                                 sizeof(ORDER*)*arg_count_order)))
unknown's avatar
unknown committed
2789
    return;
unknown's avatar
unknown committed
2790

unknown's avatar
unknown committed
2791 2792
  order= (ORDER**)(args + arg_count);

unknown's avatar
unknown committed
2793
  /* fill args items of show and sort */
unknown's avatar
unknown committed
2794
  List_iterator_fast<Item> li(*select_list);
2795

unknown's avatar
unknown committed
2796 2797
  for (arg_ptr=args ; (item_select= li++) ; arg_ptr++)
    *arg_ptr= item_select;
unknown's avatar
unknown committed
2798

unknown's avatar
unknown committed
2799
  if (arg_count_order)
unknown's avatar
SCRUM  
unknown committed
2800
  {
unknown's avatar
unknown committed
2801
    ORDER **order_ptr= order;
unknown's avatar
unknown committed
2802 2803 2804
    for (ORDER *order_item= (ORDER*) order_list->first;
         order_item != NULL;
         order_item= order_item->next)
2805
    {
unknown's avatar
unknown committed
2806 2807 2808
      (*order_ptr++)= order_item;
      *arg_ptr= *order_item->item;
      order_item->item= arg_ptr++;
2809 2810 2811
    }
  }
}
unknown's avatar
unknown committed
2812

unknown's avatar
unknown committed
2813 2814

Item_func_group_concat::Item_func_group_concat(THD *thd,
unknown's avatar
unknown committed
2815 2816
                                               Item_func_group_concat *item)
  :Item_sum(thd, item),
unknown's avatar
unknown committed
2817 2818 2819 2820 2821 2822 2823 2824 2825 2826
  tmp_table_param(item->tmp_table_param),
  warning(item->warning),
  separator(item->separator),
  tree(item->tree),
  table(item->table),
  order(item->order),
  tables_list(item->tables_list),
  arg_count_order(item->arg_count_order),
  arg_count_field(item->arg_count_field),
  count_cut_values(item->count_cut_values),
unknown's avatar
unknown committed
2827 2828 2829
  distinct(item->distinct),
  warning_for_row(item->warning_for_row),
  always_null(item->always_null),
unknown's avatar
unknown committed
2830 2831 2832 2833 2834
  original(item)
{
  quick_group= item->quick_group;
}

2835

unknown's avatar
SCRUM  
unknown committed
2836

unknown's avatar
unknown committed
2837 2838
void Item_func_group_concat::cleanup()
{
2839 2840
  THD *thd= current_thd;

unknown's avatar
unknown committed
2841
  DBUG_ENTER("Item_func_group_concat::cleanup");
2842
  Item_sum::cleanup();
unknown's avatar
unknown committed
2843

2844 2845 2846 2847 2848 2849 2850 2851 2852
  /* Adjust warning message to include total number of cut values */
  if (warning)
  {
    char warn_buff[MYSQL_ERRMSG_SIZE];
    sprintf(warn_buff, ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
    warning->set_msg(thd, warn_buff);
    warning= 0;
  }

unknown's avatar
unknown committed
2853 2854 2855 2856 2857 2858
  /*
    Free table and tree if they belong to this item (if item have not pointer
    to original item from which was made copy => it own its objects )
  */
  if (!original)
  {
unknown's avatar
unknown committed
2859 2860
    delete tmp_table_param;
    tmp_table_param= 0;
unknown's avatar
unknown committed
2861
    if (table)
unknown's avatar
unknown committed
2862
    {
unknown's avatar
unknown committed
2863
      THD *thd= table->in_use;
unknown's avatar
unknown committed
2864
      free_tmp_table(thd, table);
unknown's avatar
unknown committed
2865
      table= 0;
unknown's avatar
unknown committed
2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877
      if (tree)
      {
        delete_tree(tree);
        tree= 0;
      }
      if (warning)
      {
        char warn_buff[MYSQL_ERRMSG_SIZE];
        sprintf(warn_buff, ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
        warning->set_msg(thd, warn_buff);
        warning= 0;
      }
unknown's avatar
unknown committed
2878
    }
unknown's avatar
unknown committed
2879 2880
    DBUG_ASSERT(tree == 0);
    DBUG_ASSERT(warning == 0);
unknown's avatar
unknown committed
2881
  }
unknown's avatar
unknown committed
2882
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2883 2884
}

unknown's avatar
unknown committed
2885

2886 2887
Item *Item_func_group_concat::copy_or_same(THD* thd)
{
unknown's avatar
unknown committed
2888
  return new (thd->mem_root) Item_func_group_concat(thd, this);
2889 2890 2891
}


2892
void Item_func_group_concat::clear()
2893 2894 2895
{
  result.length(0);
  result.copy();
unknown's avatar
SCRUM  
unknown committed
2896
  null_value= TRUE;
unknown's avatar
unknown committed
2897
  warning_for_row= FALSE;
unknown's avatar
unknown committed
2898
  if (tree)
2899
    reset_tree(tree);
unknown's avatar
unknown committed
2900
  /* No need to reset the table as we never call write_row */
2901 2902
}

unknown's avatar
SCRUM  
unknown committed
2903

2904 2905
bool Item_func_group_concat::add()
{
unknown's avatar
BUG  
unknown committed
2906 2907
  if (always_null)
    return 0;
2908 2909 2910
  copy_fields(tmp_table_param);
  copy_funcs(tmp_table_param->items_to_copy);

unknown's avatar
unknown committed
2911
  for (uint i= 0; i < arg_count_field; i++)
2912
  {
unknown's avatar
unknown committed
2913
    Item *show_item= args[i];
unknown's avatar
SCRUM  
unknown committed
2914
    if (!show_item->const_item())
2915
    {
unknown's avatar
unknown committed
2916
      /*
unknown's avatar
unknown committed
2917 2918
        Here we use real_item as we want the original field data that should
        be written to table->record[0]
unknown's avatar
unknown committed
2919
      */
unknown's avatar
BUG  
unknown committed
2920
      Field *f= show_item->real_item()->get_tmp_table_field();
unknown's avatar
unknown committed
2921
      if (f->is_null())
unknown's avatar
unknown committed
2922
        return 0;                               // Skip row if it contains null
2923 2924
    }
  }
unknown's avatar
unknown committed
2925

unknown's avatar
SCRUM  
unknown committed
2926
  null_value= FALSE;
2927 2928

  TREE_ELEMENT *el= 0;                          // Only for safety
unknown's avatar
unknown committed
2929 2930 2931
  if (tree)
    el= tree_insert(tree, table->record[0] + table->s->null_bytes, 0,
                    tree->custom_arg);
2932 2933 2934 2935 2936
  /*
    If the row is not a duplicate (el->count == 1)
    we can dump the row here in case of GROUP_CONCAT(DISTINCT...)
    instead of doing tree traverse later.
  */
unknown's avatar
unknown committed
2937
  if (result.length() <= max_length &&
2938
      !warning_for_row &&
unknown's avatar
unknown committed
2939 2940
      (!tree || (el->count == 1 && distinct && !arg_count_order)))
    dump_leaf_key(table->record[0] + table->s->null_bytes, 1, this);
2941

2942 2943 2944
  return 0;
}

unknown's avatar
SCRUM  
unknown committed
2945

2946 2947 2948
bool
Item_func_group_concat::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
{
unknown's avatar
unknown committed
2949
  uint i;                       /* for loop variable */
2950
  DBUG_ASSERT(fixed == 0);
unknown's avatar
unknown committed
2951

2952 2953
  if (!thd->allow_sum_func)
  {
unknown's avatar
unknown committed
2954 2955
    my_message(ER_INVALID_GROUP_FUNC_USE, ER(ER_INVALID_GROUP_FUNC_USE),
               MYF(0));
unknown's avatar
unknown committed
2956
    return TRUE;
2957
  }
unknown's avatar
unknown committed
2958

unknown's avatar
SCRUM  
unknown committed
2959 2960
  thd->allow_sum_func= 0;
  maybe_null= 0;
unknown's avatar
unknown committed
2961

unknown's avatar
SCRUM  
unknown committed
2962
  /*
unknown's avatar
unknown committed
2963
    Fix fields for select list and ORDER clause
unknown's avatar
SCRUM  
unknown committed
2964
  */
unknown's avatar
unknown committed
2965

unknown's avatar
unknown committed
2966
  for (i=0 ; i < arg_count ; i++)
2967
  {
unknown's avatar
unknown committed
2968
    if ((!args[i]->fixed &&
unknown's avatar
unknown committed
2969 2970
         args[i]->fix_fields(thd, tables, args + i)) ||
        args[i]->check_cols(1))
unknown's avatar
unknown committed
2971
      return TRUE;
unknown's avatar
unknown committed
2972
    if (i < arg_count_field)
unknown's avatar
unknown committed
2973
      maybe_null|= args[i]->maybe_null;
2974
  }
unknown's avatar
unknown committed
2975

unknown's avatar
SCRUM  
unknown committed
2976 2977
  result_field= 0;
  null_value= 1;
unknown's avatar
unknown committed
2978
  thd->allow_sum_func= 1;
unknown's avatar
unknown committed
2979
  max_length= thd->variables.group_concat_max_len;
unknown's avatar
SCRUM  
unknown committed
2980
  tables_list= tables;
2981
  fixed= 1;
unknown's avatar
unknown committed
2982
  return FALSE;
2983 2984
}

unknown's avatar
SCRUM  
unknown committed
2985

2986 2987 2988
bool Item_func_group_concat::setup(THD *thd)
{
  List<Item> list;
unknown's avatar
unknown committed
2989
  SELECT_LEX *select_lex= thd->lex->current_select;
unknown's avatar
unknown committed
2990 2991
  qsort_cmp2 compare_key;
  DBUG_ENTER("Item_func_group_concat::setup");
2992

unknown's avatar
SCRUM  
unknown committed
2993
  /*
unknown's avatar
unknown committed
2994 2995
    Currently setup() can be called twice. Please add
    assertion here when this is fixed.
unknown's avatar
unknown committed
2996
  */
unknown's avatar
unknown committed
2997 2998 2999 3000 3001 3002 3003 3004 3005
  if (table || tree)
    DBUG_RETURN(FALSE);

  if (!(tmp_table_param= new TMP_TABLE_PARAM))
    DBUG_RETURN(TRUE);

  /* We'll convert all blobs to varchar fields in the temporary table */
  tmp_table_param->convert_blob_length= max_length;
  /* Push all not constant fields to the list and create a temp table */
unknown's avatar
BUG  
unknown committed
3006
  always_null= 0;
unknown's avatar
unknown committed
3007
  for (uint i= 0; i < arg_count_field; i++)
3008
  {
unknown's avatar
SCRUM  
unknown committed
3009
    Item *item= args[i];
3010
    if (list.push_back(item))
unknown's avatar
unknown committed
3011
      DBUG_RETURN(TRUE);
3012 3013
    if (item->const_item())
    {
3014
      if (item->is_null())
unknown's avatar
unknown committed
3015 3016
      {
        always_null= 1;
unknown's avatar
unknown committed
3017
        DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
3018
      }
3019 3020
    }
  }
unknown's avatar
unknown committed
3021

3022
  List<Item> all_fields(list);
unknown's avatar
unknown committed
3023 3024 3025 3026 3027 3028 3029 3030 3031
  /*
    Try to find every ORDER expression in the list of GROUP_CONCAT
    arguments. If an expression is not found, prepend it to
    "all_fields". The resulting field list is used as input to create
    tmp table columns.
  */
  if (arg_count_order &&
      setup_order(thd, args, tables_list, list, all_fields, *order))
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
3032

3033
  count_field_types(tmp_table_param,all_fields,0);
unknown's avatar
unknown committed
3034
  DBUG_ASSERT(table == 0);
unknown's avatar
SCRUM  
unknown committed
3035
  /*
unknown's avatar
unknown committed
3036
    We have to create a temporary table to get descriptions of fields
unknown's avatar
SCRUM  
unknown committed
3037
    (types, sizes and so on).
unknown's avatar
unknown committed
3038 3039 3040

    Note that in the table, we first have the ORDER BY fields, then the
    field list.
unknown's avatar
unknown committed
3041

unknown's avatar
unknown committed
3042 3043
    We need to set set_sum_field in true for storing value of blob in buffer
    of a record instead of a pointer of one.
unknown's avatar
SCRUM  
unknown committed
3044
  */
unknown's avatar
unknown committed
3045 3046 3047 3048 3049
  if (!(table= create_tmp_table(thd, tmp_table_param, all_fields,
                                (ORDER*) 0, 0, TRUE,
                                select_lex->options | thd->options,
                                HA_POS_ERROR, (char*) "")))
    DBUG_RETURN(TRUE);
3050
  table->file->extra(HA_EXTRA_NO_ROWS);
unknown's avatar
SCRUM  
unknown committed
3051
  table->no_rows= 1;
unknown's avatar
unknown committed
3052 3053


unknown's avatar
unknown committed
3054
  if (distinct || arg_count_order)
3055
  {
unknown's avatar
unknown committed
3056 3057 3058 3059 3060 3061 3062 3063
    /*
      Need sorting: init tree and choose a function to sort.
      Don't reserve space for NULLs: if any of gconcat arguments is NULL,
      the row is not added to the result.
    */
    uint tree_key_length= table->s->reclength - table->s->null_bytes;

    tree= &tree_base;
3064 3065 3066
    if (arg_count_order)
    {
      if (distinct)
unknown's avatar
SCRUM  
unknown committed
3067
        compare_key= (qsort_cmp2) group_concat_key_cmp_with_distinct_and_order;
3068
      else
unknown's avatar
SCRUM  
unknown committed
3069
        compare_key= (qsort_cmp2) group_concat_key_cmp_with_order;
3070 3071 3072
    }
    else
    {
3073
      compare_key= (qsort_cmp2) group_concat_key_cmp_with_distinct;
3074
    }
unknown's avatar
SCRUM  
unknown committed
3075
    /*
unknown's avatar
unknown committed
3076 3077 3078
      Create a tree for sorting. The tree is used to sort and to remove
      duplicate values (according to the syntax of this function). If there
      is no DISTINCT or ORDER BY clauses, we don't create this tree.
unknown's avatar
SCRUM  
unknown committed
3079
    */
3080
    init_tree(tree, min(thd->variables.max_heap_table_size,
unknown's avatar
unknown committed
3081 3082
                        thd->variables.sortbuff_size/16), 0,
              tree_key_length, compare_key, 0, NULL, (void*) this);
3083
  }
unknown's avatar
unknown committed
3084 3085

  DBUG_RETURN(FALSE);
3086 3087
}

unknown's avatar
unknown committed
3088

3089 3090 3091 3092
/* This is used by rollup to create a separate usable copy of the function */

void Item_func_group_concat::make_unique()
{
unknown's avatar
unknown committed
3093
  tmp_table_param= 0;
3094 3095
  table=0;
  original= 0;
unknown's avatar
unknown committed
3096
  tree= 0;
3097 3098 3099
}


3100 3101
String* Item_func_group_concat::val_str(String* str)
{
3102
  DBUG_ASSERT(fixed == 1);
unknown's avatar
SCRUM  
unknown committed
3103 3104
  if (null_value)
    return 0;
3105
  if (count_cut_values && !warning)
unknown's avatar
unknown committed
3106
  {
3107 3108 3109 3110
    /*
      ER_CUT_VALUE_GROUP_CONCAT needs an argument, but this gets set in
      Item_func_group_concat::cleanup().
    */
unknown's avatar
unknown committed
3111 3112
    DBUG_ASSERT(table);
    warning= push_warning(table->in_use, MYSQL_ERROR::WARN_LEVEL_WARN,
3113 3114
                          ER_CUT_VALUE_GROUP_CONCAT,
                          ER(ER_CUT_VALUE_GROUP_CONCAT));
unknown's avatar
unknown committed
3115
  }
3116 3117
  if (result.length())
    return &result;
unknown's avatar
unknown committed
3118
  if (tree)
3119 3120 3121 3122
    tree_walk(tree, (tree_walk_action)&dump_leaf_key, (void*)this,
              left_root_right);
  return &result;
}
3123

unknown's avatar
unknown committed
3124

3125 3126
void Item_func_group_concat::print(String *str)
{
3127
  str->append("group_concat(", 13);
3128
  if (distinct)
3129
    str->append("distinct ", 9);
unknown's avatar
unknown committed
3130
  for (uint i= 0; i < arg_count_field; i++)
3131 3132 3133 3134 3135 3136 3137
  {
    if (i)
      str->append(',');
    args[i]->print(str);
  }
  if (arg_count_order)
  {
3138
    str->append(" order by ", 10);
3139 3140 3141
    for (uint i= 0 ; i < arg_count_order ; i++)
    {
      if (i)
unknown's avatar
unknown committed
3142
        str->append(',');
3143 3144 3145
      (*order[i]->item)->print(str);
    }
  }
3146
  str->append(" separator \'", 12);
3147
  str->append(*separator);
3148
  str->append("\')", 2);
3149
}