← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item_sum.cc

  • Committer: Brian Aker
  • Date: 2008-10-11 21:01:52 UTC
  • Revision ID: brian@tangent.org-20081011210152-8ipnqumvhtt1zcmj
Added back more tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item_sum.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
 
17
17
/**
20
20
  @brief
21
21
  Sum functions (COUNT, MIN...)
22
22
*/
23
 
#include "config.h"
24
 
#include <cstdio>
25
 
#include <math.h>
 
23
#include <drizzled/server_includes.h>
26
24
#include <drizzled/sql_select.h>
27
 
#include <drizzled/error.h>
28
 
#include <drizzled/hybrid_type_traits.h>
29
 
#include <drizzled/hybrid_type_traits_integer.h>
30
 
#include <drizzled/hybrid_type_traits_decimal.h>
31
 
#include <drizzled/sql_base.h>
32
 
 
33
 
#include <drizzled/item/sum.h>
34
 
#include <drizzled/field/decimal.h>
35
 
#include <drizzled/field/double.h>
36
 
#include <drizzled/field/int64.h>
37
 
#include <drizzled/field/date.h>
38
 
#include <drizzled/field/datetime.h>
39
 
 
40
 
#include "drizzled/internal/m_string.h"
41
 
 
42
 
#include <algorithm>
43
 
 
44
 
using namespace std;
45
 
 
46
 
namespace drizzled
47
 
{
48
 
 
49
 
extern my_decimal decimal_zero;
50
 
extern plugin::StorageEngine *heap_engine;
 
25
#include <drizzled/drizzled_error_messages.h>
51
26
 
52
27
/**
53
28
  Prepare an aggregate function item for checking context conditions.
58
33
    If the set function is not allowed in any subquery where it occurs
59
34
    an error is reported immediately.
60
35
 
61
 
  @param session      reference to the thread context info
 
36
  @param thd      reference to the thread context info
62
37
 
63
38
  @note
64
39
    This function is to be called for any item created for a set function
70
45
  @retval
71
46
    FALSE  otherwise
72
47
*/
73
 
 
74
 
bool Item_sum::init_sum_func_check(Session *session)
 
48
 
 
49
bool Item_sum::init_sum_func_check(THD *thd)
75
50
{
76
 
  if (!session->lex->allow_sum_func)
 
51
  if (!thd->lex->allow_sum_func)
77
52
  {
78
53
    my_message(ER_INVALID_GROUP_FUNC_USE, ER(ER_INVALID_GROUP_FUNC_USE),
79
54
               MYF(0));
80
55
    return true;
81
56
  }
82
57
  /* Set a reference to the nesting set function if there is  any */
83
 
  in_sum_func= session->lex->in_sum_func;
 
58
  in_sum_func= thd->lex->in_sum_func;
84
59
  /* Save a pointer to object to be used in items for nested set functions */
85
 
  session->lex->in_sum_func= this;
86
 
  nest_level= session->lex->current_select->nest_level;
 
60
  thd->lex->in_sum_func= this;
 
61
  nest_level= thd->lex->current_select->nest_level;
87
62
  ref_by= 0;
88
63
  aggr_level= -1;
89
64
  aggr_sel= NULL;
105
80
    If the context conditions are not met the method reports an error.
106
81
    If the set function is aggregated in some outer subquery the method
107
82
    adds it to the chain of items for such set functions that is attached
108
 
    to the the Select_Lex structure for this subquery.
 
83
    to the the st_select_lex structure for this subquery.
109
84
 
110
85
    A number of designated members of the object are used to check the
111
86
    conditions. They are specified in the comment before the Item_sum
112
87
    class declaration.
113
88
    Additionally a bitmap variable called allow_sum_func is employed.
114
 
    It is included into the session->lex structure.
 
89
    It is included into the thd->lex structure.
115
90
    The bitmap contains 1 at n-th position if the set function happens
116
91
    to occur under a construct of the n-th level subquery where usage
117
92
    of set functions are allowed (i.e either in the SELECT list or
122
97
         HAVING t1.a IN (SELECT t2.c FROM t2 WHERE AVG(t1.b) > 20) AND
123
98
                t1.a > (SELECT MIN(t2.d) FROM t2);
124
99
    @endcode
125
 
    allow_sum_func will contain:
126
 
    - for SUM(t1.b) - 1 at the first position
 
100
    allow_sum_func will contain: 
 
101
    - for SUM(t1.b) - 1 at the first position 
127
102
    - for AVG(t1.b) - 1 at the first position, 0 at the second position
128
103
    - for MIN(t2.d) - 1 at the first position, 1 at the second position.
129
104
 
130
 
  @param session  reference to the thread context info
 
105
  @param thd  reference to the thread context info
131
106
  @param ref  location of the pointer to this item in the embedding expression
132
107
 
133
108
  @note
141
116
  @retval
142
117
    FALSE  otherwise
143
118
*/
144
 
 
145
 
bool Item_sum::check_sum_func(Session *session, Item **ref)
 
119
 
 
120
bool Item_sum::check_sum_func(THD *thd, Item **ref)
146
121
{
147
122
  bool invalid= false;
148
 
  nesting_map allow_sum_func= session->lex->allow_sum_func;
149
 
  /*
 
123
  nesting_map allow_sum_func= thd->lex->allow_sum_func;
 
124
  /*  
150
125
    The value of max_arg_level is updated if an argument of the set function
151
126
    contains a column reference resolved  against a subquery whose level is
152
127
    greater than the current value of max_arg_level.
153
128
    max_arg_level cannot be greater than nest level.
154
 
    nest level is always >= 0
155
 
  */
 
129
    nest level is always >= 0  
 
130
  */ 
156
131
  if (nest_level == max_arg_level)
157
132
  {
158
133
    /*
159
 
      The function must be aggregated in the current subquery,
160
 
      If it is there under a construct where it is not allowed
161
 
      we report an error.
162
 
    */
 
134
      The function must be aggregated in the current subquery, 
 
135
      If it is there under a construct where it is not allowed 
 
136
      we report an error. 
 
137
    */ 
163
138
    invalid= !(allow_sum_func & (1 << max_arg_level));
164
139
  }
165
140
  else if (max_arg_level >= 0 || !(allow_sum_func & (1 << nest_level)))
169
144
      Try to find a subquery where it can be aggregated;
170
145
      If we fail to find such a subquery report an error.
171
146
    */
172
 
    if (register_sum_func(session, ref))
 
147
    if (register_sum_func(thd, ref))
173
148
      return true;
174
149
    invalid= aggr_level < 0 && !(allow_sum_func & (1 << nest_level));
175
150
    if (!invalid && false)
178
153
  if (!invalid && aggr_level < 0)
179
154
  {
180
155
    aggr_level= nest_level;
181
 
    aggr_sel= session->lex->current_select;
 
156
    aggr_sel= thd->lex->current_select;
182
157
  }
183
158
  /*
184
159
    By this moment we either found a subquery where the set function is
185
160
    to be aggregated  and assigned a value that is  >= 0 to aggr_level,
186
 
    or set the value of 'invalid' to TRUE to report later an error.
 
161
    or set the value of 'invalid' to TRUE to report later an error. 
187
162
  */
188
 
  /*
 
163
  /* 
189
164
    Additionally we have to check whether possible nested set functions
190
165
    are acceptable here: they are not, if the level of aggregation of
191
166
    some of them is less than aggr_level.
192
167
  */
193
 
  if (!invalid)
 
168
  if (!invalid) 
194
169
    invalid= aggr_level <= max_sum_func_level;
195
 
  if (invalid)
 
170
  if (invalid)  
196
171
  {
197
172
    my_message(ER_INVALID_GROUP_FUNC_USE, ER(ER_INVALID_GROUP_FUNC_USE),
198
173
               MYF(0));
204
179
    /*
205
180
      If the set function is nested adjust the value of
206
181
      max_sum_func_level for the nesting set function.
207
 
      We take into account only enclosed set functions that are to be
208
 
      aggregated on the same level or above of the nest level of
 
182
      We take into account only enclosed set functions that are to be 
 
183
      aggregated on the same level or above of the nest level of 
209
184
      the enclosing set function.
210
185
      But we must always pass up the max_sum_func_level because it is
211
186
      the maximum nested level of all directly and indirectly enclosed
256
231
    List_iterator<Item_field> of(outer_fields);
257
232
    while ((field= of++))
258
233
    {
259
 
      Select_Lex *sel= field->cached_table->select_lex;
 
234
      SELECT_LEX *sel= field->cached_table->select_lex;
260
235
      if (sel->nest_level < aggr_level)
261
236
      {
262
237
        if (in_sum_func)
268
243
          in_sum_func->outer_fields.push_back(field);
269
244
        }
270
245
        else
271
 
        {
272
 
          sel->full_group_by_flag.set(NON_AGG_FIELD_USED);
273
 
        }
 
246
          sel->full_group_by_flag|= NON_AGG_FIELD_USED;
274
247
      }
275
248
      if (sel->nest_level > aggr_level &&
276
 
          (sel->full_group_by_flag.test(SUM_FUNC_USED)) &&
277
 
          ! sel->group_list.elements)
 
249
          (sel->full_group_by_flag & SUM_FUNC_USED) &&
 
250
          !sel->group_list.elements)
278
251
      {
279
252
        my_message(ER_MIX_OF_GROUP_FUNC_AND_FIELDS,
280
253
                   ER(ER_MIX_OF_GROUP_FUNC_AND_FIELDS), MYF(0));
282
255
      }
283
256
    }
284
257
  }
285
 
  aggr_sel->full_group_by_flag.set(SUM_FUNC_USED);
 
258
  aggr_sel->full_group_by_flag|= SUM_FUNC_USED;
286
259
  update_used_tables();
287
 
  session->lex->in_sum_func= in_sum_func;
 
260
  thd->lex->in_sum_func= in_sum_func;
288
261
  return false;
289
262
}
290
263
 
295
268
    aggregated. If it finds such a subquery then aggr_level is set to
296
269
    the nest level of this subquery and the item for the set function
297
270
    is added to the list of set functions used in nested subqueries
298
 
    inner_sum_func_list defined for each subquery. When the item is placed
 
271
    inner_sum_func_list defined for each subquery. When the item is placed 
299
272
    there the field 'ref_by' is set to ref.
300
273
 
301
274
  @note
304
277
    a subquery in one chain. It would simplify the process of 'splitting'
305
278
    for set functions.
306
279
 
307
 
  @param session  reference to the thread context info
 
280
  @param thd  reference to the thread context info
308
281
  @param ref  location of the pointer to this item in the embedding expression
309
282
 
310
283
  @retval
311
284
    FALSE  if the executes without failures (currently always)
312
285
  @retval
313
286
    TRUE   otherwise
314
 
*/
 
287
*/  
315
288
 
316
 
bool Item_sum::register_sum_func(Session *session, Item **ref)
 
289
bool Item_sum::register_sum_func(THD *thd, Item **ref)
317
290
{
318
 
  Select_Lex *sl;
319
 
  nesting_map allow_sum_func= session->lex->allow_sum_func;
320
 
  for (sl= session->lex->current_select->master_unit()->outer_select() ;
 
291
  SELECT_LEX *sl;
 
292
  nesting_map allow_sum_func= thd->lex->allow_sum_func;
 
293
  for (sl= thd->lex->current_select->master_unit()->outer_select() ;
321
294
       sl && sl->nest_level > max_arg_level;
322
295
       sl= sl->master_unit()->outer_select() )
323
296
  {
330
303
  }
331
304
  if (sl && (allow_sum_func & (1 << sl->nest_level)))
332
305
  {
333
 
    /*
 
306
    /* 
334
307
      We reached the subquery of level max_arg_level and checked
335
 
      that the function can be aggregated here.
 
308
      that the function can be aggregated here. 
336
309
      The set function will be aggregated in this subquery.
337
 
    */
 
310
    */   
338
311
    aggr_level= sl->nest_level;
339
312
    aggr_sel= sl;
340
313
 
353
326
    aggr_sel->inner_sum_func_list= this;
354
327
    aggr_sel->with_sum_func= 1;
355
328
 
356
 
    /*
 
329
    /* 
357
330
      Mark Item_subselect(s) as containing aggregate function all the way up
358
331
      to aggregate function's calculation context.
359
332
      Note that we must not mark the Item of calculation context itself
360
 
      because with_sum_func on the calculation context Select_Lex is
 
333
      because with_sum_func on the calculation context st_select_lex is
361
334
      already set above.
362
335
 
363
 
      with_sum_func being set for an Item means that this Item refers
 
336
      with_sum_func being set for an Item means that this Item refers 
364
337
      (somewhere in it, e.g. one of its arguments if it's a function) directly
365
338
      or through intermediate items to an aggregate function that is calculated
366
339
      in a context "outside" of the Item (e.g. in the current or outer select).
367
340
 
368
 
      with_sum_func being set for an Select_Lex means that this Select_Lex
 
341
      with_sum_func being set for an st_select_lex means that this st_select_lex
369
342
      has aggregate functions directly referenced (i.e. not through a sub-select).
370
343
    */
371
 
    for (sl= session->lex->current_select;
 
344
    for (sl= thd->lex->current_select; 
372
345
         sl && sl != aggr_sel && sl->master_unit()->item;
373
346
         sl= sl->master_unit()->outer_select() )
374
347
      sl->master_unit()->item->with_sum_func= 1;
375
348
  }
376
 
  session->lex->current_select->mark_as_dependent(aggr_sel);
 
349
  thd->lex->current_select->mark_as_dependent(aggr_sel);
377
350
  return false;
378
351
}
379
352
 
380
353
 
381
 
Item_sum::Item_sum(List<Item> &list) :arg_count(list.elements),
 
354
Item_sum::Item_sum(List<Item> &list) :arg_count(list.elements), 
382
355
  forced_const(false)
383
356
{
384
 
  if ((args=(Item**) memory::sql_alloc(sizeof(Item*)*arg_count)))
 
357
  if ((args=(Item**) sql_alloc(sizeof(Item*)*arg_count)))
385
358
  {
386
359
    uint32_t i=0;
387
360
    List_iterator_fast<Item> li(list);
401
374
  Constructor used in processing select with temporary tebles.
402
375
*/
403
376
 
404
 
Item_sum::Item_sum(Session *session, Item_sum *item):
405
 
  Item_result_field(session, item), arg_count(item->arg_count),
 
377
Item_sum::Item_sum(THD *thd, Item_sum *item):
 
378
  Item_result_field(thd, item), arg_count(item->arg_count),
406
379
  aggr_sel(item->aggr_sel),
407
380
  nest_level(item->nest_level), aggr_level(item->aggr_level),
408
381
  quick_group(item->quick_group), used_tables_cache(item->used_tables_cache),
409
 
  forced_const(item->forced_const)
 
382
  forced_const(item->forced_const) 
410
383
{
411
384
  if (arg_count <= 2)
412
385
    args=tmp_args;
413
386
  else
414
 
    if (!(args= (Item**) session->alloc(sizeof(Item*)*arg_count)))
 
387
    if (!(args= (Item**) thd->alloc(sizeof(Item*)*arg_count)))
415
388
      return;
416
389
  memcpy(args, item->args, sizeof(Item*)*arg_count);
417
390
}
419
392
 
420
393
void Item_sum::mark_as_sum_func()
421
394
{
422
 
  Select_Lex *cur_select= current_session->lex->current_select;
 
395
  SELECT_LEX *cur_select= current_thd->lex->current_select;
423
396
  cur_select->n_sum_items++;
424
397
  cur_select->with_sum_func= 1;
425
398
  with_sum_func= 1;
426
399
}
427
400
 
428
401
 
429
 
void Item_sum::make_field(SendField *tmp_field)
 
402
void Item_sum::make_field(Send_field *tmp_field)
430
403
{
431
404
  if (args[0]->type() == Item::FIELD_ITEM && keep_field_type())
432
405
  {
466
439
  max_length=float_length(decimals);
467
440
}
468
441
 
469
 
Item *Item_sum::get_tmp_table_item(Session *session)
 
442
Item *Item_sum::get_tmp_table_item(THD *thd)
470
443
{
471
 
  Item_sum* sum_item= (Item_sum *) copy_or_same(session);
 
444
  Item_sum* sum_item= (Item_sum *) copy_or_same(thd);
472
445
  if (sum_item && sum_item->result_field)          // If not a const sum func
473
446
  {
474
447
    Field *result_field_tmp= sum_item->result_field;
504
477
}
505
478
 
506
479
 
507
 
Field *Item_sum::create_tmp_field(bool ,
 
480
Field *Item_sum::create_tmp_field(bool group __attribute__((unused)),
508
481
                                  Table *table,
509
482
                                  uint32_t convert_blob_length)
510
483
{
511
 
  Field *field= NULL;
512
 
 
 
484
  Field *field;
513
485
  switch (result_type()) {
514
486
  case REAL_RESULT:
515
487
    field= new Field_double(max_length, maybe_null, name, decimals, true);
516
488
    break;
517
 
 
518
489
  case INT_RESULT:
519
 
    field= new field::Int64(max_length, maybe_null, name, unsigned_flag);
 
490
    field= new Field_int64_t(max_length, maybe_null, name, unsigned_flag);
520
491
    break;
521
 
 
522
492
  case STRING_RESULT:
523
493
    if (max_length/collation.collation->mbmaxlen <= 255 ||
524
494
        convert_blob_length > Field_varstring::MAX_SIZE ||
525
495
        !convert_blob_length)
526
 
    {
527
496
      return make_string_field(table);
528
 
    }
529
 
 
530
 
    table->setVariableWidth();
531
497
    field= new Field_varstring(convert_blob_length, maybe_null,
532
 
                               name, collation.collation);
 
498
                               name, table->s, collation.collation);
533
499
    break;
534
 
 
535
500
  case DECIMAL_RESULT:
536
 
    field= new Field_decimal(max_length, maybe_null, name,
537
 
                             decimals, unsigned_flag);
 
501
    field= new Field_new_decimal(max_length, maybe_null, name,
 
502
                                 decimals, unsigned_flag);
538
503
    break;
539
 
 
540
504
  case ROW_RESULT:
 
505
  default:
541
506
    // This case should never be choosen
542
507
    assert(0);
543
508
    return 0;
544
509
  }
545
 
 
546
510
  if (field)
547
511
    field->init(table);
548
 
 
549
512
  return field;
550
513
}
551
514
 
576
539
}
577
540
 
578
541
 
579
 
int64_t Item_sum_num::val_int()
580
 
{
581
 
  assert(fixed == 1);
582
 
  return (int64_t) rint(val_real());             /* Real as default */
583
 
}
584
 
 
585
 
 
586
542
my_decimal *Item_sum_num::val_decimal(my_decimal *decimal_value)
587
543
{
588
544
  return val_decimal_from_real(decimal_value);
603
559
 
604
560
 
605
561
bool
606
 
Item_sum_num::fix_fields(Session *session, Item **ref)
 
562
Item_sum_num::fix_fields(THD *thd, Item **ref)
607
563
{
608
564
  assert(fixed == 0);
609
565
 
610
 
  if (init_sum_func_check(session))
 
566
  if (init_sum_func_check(thd))
611
567
    return true;
612
568
 
613
569
  decimals=0;
614
570
  maybe_null=0;
615
571
  for (uint32_t i=0 ; i < arg_count ; i++)
616
572
  {
617
 
    if (args[i]->fix_fields(session, args + i) || args[i]->check_cols(1))
 
573
    if (args[i]->fix_fields(thd, args + i) || args[i]->check_cols(1))
618
574
      return true;
619
575
    set_if_bigger(decimals, args[i]->decimals);
620
576
    maybe_null |= args[i]->maybe_null;
624
580
  null_value=1;
625
581
  fix_length_and_dec();
626
582
 
627
 
  if (check_sum_func(session, ref))
 
583
  if (check_sum_func(thd, ref))
628
584
    return true;
629
585
 
630
586
  fixed= 1;
632
588
}
633
589
 
634
590
 
635
 
Item_sum_hybrid::Item_sum_hybrid(Session *session, Item_sum_hybrid *item)
636
 
  :Item_sum(session, item), value(item->value), hybrid_type(item->hybrid_type),
 
591
Item_sum_hybrid::Item_sum_hybrid(THD *thd, Item_sum_hybrid *item)
 
592
  :Item_sum(thd, item), value(item->value), hybrid_type(item->hybrid_type),
637
593
  hybrid_field_type(item->hybrid_field_type), cmp_sign(item->cmp_sign),
638
594
  was_values(item->was_values)
639
595
{
655
611
    */
656
612
    break;
657
613
  case ROW_RESULT:
 
614
  default:
658
615
    assert(0);
659
616
  }
660
617
  collation.set(item->collation);
661
618
}
662
619
 
663
620
bool
664
 
Item_sum_hybrid::fix_fields(Session *session, Item **ref)
 
621
Item_sum_hybrid::fix_fields(THD *thd, Item **ref)
665
622
{
666
623
  assert(fixed == 0);
667
624
 
668
625
  Item *item= args[0];
669
626
 
670
 
  if (init_sum_func_check(session))
 
627
  if (init_sum_func_check(thd))
671
628
    return true;
672
629
 
673
630
  // 'item' can be changed during fix_fields
674
 
  if ((!item->fixed && item->fix_fields(session, args)) ||
 
631
  if ((!item->fixed && item->fix_fields(thd, args)) ||
675
632
      (item= args[0])->check_cols(1))
676
633
    return true;
677
634
  decimals=item->decimals;
693
650
    max_length= item->max_length;
694
651
    break;
695
652
  case ROW_RESULT:
 
653
  default:
696
654
    assert(0);
697
655
  };
698
656
  /* MIN/MAX can return NULL for empty set indepedent of the used column */
708
666
  else
709
667
    hybrid_field_type= Item::field_type();
710
668
 
711
 
  if (check_sum_func(session, ref))
 
669
  if (check_sum_func(thd, ref))
712
670
    return true;
713
671
 
714
672
  fixed= 1;
722
680
  if (args[0]->type() == Item::FIELD_ITEM)
723
681
  {
724
682
    field= ((Item_field*) args[0])->field;
725
 
 
726
 
    if ((field= create_tmp_field_from_field(current_session, field, name, table,
 
683
    
 
684
    if ((field= create_tmp_field_from_field(current_thd, field, name, table,
727
685
                                            NULL, convert_blob_length)))
728
686
      field->flags&= ~NOT_NULL_FLAG;
729
687
    return field;
734
692
    fields creations separately.
735
693
  */
736
694
  switch (args[0]->field_type()) {
737
 
  case DRIZZLE_TYPE_DATE:
738
 
    field= new Field_date(maybe_null, name, collation.collation);
 
695
  case DRIZZLE_TYPE_NEWDATE:
 
696
    field= new Field_newdate(maybe_null, name, collation.collation);
 
697
    break;
 
698
  case DRIZZLE_TYPE_TIME:
 
699
    field= new Field_time(maybe_null, name, collation.collation);
739
700
    break;
740
701
  case DRIZZLE_TYPE_TIMESTAMP:
741
702
  case DRIZZLE_TYPE_DATETIME:
758
719
  @todo
759
720
  check if the following assignments are really needed
760
721
*/
761
 
Item_sum_sum::Item_sum_sum(Session *session, Item_sum_sum *item)
762
 
  :Item_sum_num(session, item), hybrid_type(item->hybrid_type),
 
722
Item_sum_sum::Item_sum_sum(THD *thd, Item_sum_sum *item) 
 
723
  :Item_sum_num(thd, item), hybrid_type(item->hybrid_type),
763
724
   curr_dec_buff(item->curr_dec_buff)
764
725
{
765
726
  /* TODO: check if the following assignments are really needed */
772
733
    sum= item->sum;
773
734
}
774
735
 
775
 
Item *Item_sum_sum::copy_or_same(Session* session)
 
736
Item *Item_sum_sum::copy_or_same(THD* thd)
776
737
{
777
 
  return new (session->mem_root) Item_sum_sum(session, this);
 
738
  return new (thd->mem_root) Item_sum_sum(thd, this);
778
739
}
779
740
 
780
741
 
804
765
    break;
805
766
  case INT_RESULT:
806
767
  case DECIMAL_RESULT:
807
 
    {
808
 
      /* SUM result can't be longer than length(arg) + length(MAX_ROWS) */
809
 
      int precision= args[0]->decimal_precision() + DECIMAL_LONGLONG_DIGITS;
810
 
      max_length= my_decimal_precision_to_length(precision, decimals,
811
 
                                                 unsigned_flag);
812
 
      curr_dec_buff= 0;
813
 
      hybrid_type= DECIMAL_RESULT;
814
 
      my_decimal_set_zero(dec_buffs);
815
 
      break;
816
 
    }
 
768
  {
 
769
    /* SUM result can't be longer than length(arg) + length(MAX_ROWS) */
 
770
    int precision= args[0]->decimal_precision() + DECIMAL_LONGLONG_DIGITS;
 
771
    max_length= my_decimal_precision_to_length(precision, decimals,
 
772
                                               unsigned_flag);
 
773
    curr_dec_buff= 0;
 
774
    hybrid_type= DECIMAL_RESULT;
 
775
    my_decimal_set_zero(dec_buffs);
 
776
    break;
 
777
  }
817
778
  case ROW_RESULT:
 
779
  default:
818
780
    assert(0);
819
781
  }
 
782
  return;
820
783
}
821
784
 
822
785
 
883
846
 
884
847
/***************************************************************************/
885
848
 
 
849
#ifdef __cplusplus
 
850
extern "C" {
 
851
#endif
 
852
 
886
853
/* Declarations for auxilary C-callbacks */
887
854
 
888
855
static int simple_raw_key_cmp(void* arg, const void* key1, const void* key2)
892
859
 
893
860
 
894
861
static int item_sum_distinct_walk(void *element,
895
 
                                  uint32_t ,
 
862
                                  element_count num_of_dups __attribute__((unused)),
896
863
                                  void *item)
897
864
{
898
865
  return ((Item_sum_distinct*) (item))->unique_walk_function(element);
899
866
}
900
867
 
 
868
#ifdef __cplusplus
 
869
}
 
870
#endif
 
871
 
901
872
/* Item_sum_distinct */
902
873
 
903
874
Item_sum_distinct::Item_sum_distinct(Item *item_arg)
913
884
}
914
885
 
915
886
 
916
 
Item_sum_distinct::Item_sum_distinct(Session *session, Item_sum_distinct *original)
917
 
  :Item_sum_num(session, original), val(original->val), tree(0),
 
887
Item_sum_distinct::Item_sum_distinct(THD *thd, Item_sum_distinct *original)
 
888
  :Item_sum_num(thd, original), val(original->val), tree(0),
918
889
  table_field_type(original->table_field_type)
919
890
{
920
891
  quick_group= 0;
954
925
  return &fast_decimal_traits_instance;
955
926
}
956
927
 
957
 
 
958
928
void Item_sum_distinct::fix_length_and_dec()
959
929
{
960
930
  assert(args[0]->fixed);
961
931
 
962
 
  null_value= maybe_null= true;
963
932
  table_field_type= args[0]->field_type();
964
933
 
965
934
  /* Adjust tmp table type according to the chosen aggregation type */
970
939
    table_field_type= DRIZZLE_TYPE_DOUBLE;
971
940
    break;
972
941
  case INT_RESULT:
973
 
    /*
974
 
      Preserving int8, int16, int32 field types gives ~10% performance boost
975
 
      as the size of result tree becomes significantly smaller.
976
 
      Another speed up we gain by using int64_t for intermediate
977
 
      calculations. The range of int64 is enough to hold sum 2^32 distinct
978
 
      integers each <= 2^32.
979
 
    */
980
 
    if (table_field_type == DRIZZLE_TYPE_LONG)
981
 
    {
982
 
      val.traits= Hybrid_type_traits_fast_decimal::instance();
983
 
      break;
984
 
    }
985
 
    table_field_type= DRIZZLE_TYPE_LONGLONG;
986
 
    /* fallthrough */
 
942
  /*
 
943
    Preserving int8, int16, int32 field types gives ~10% performance boost
 
944
    as the size of result tree becomes significantly smaller.
 
945
    Another speed up we gain by using int64_t for intermediate
 
946
    calculations. The range of int64 is enough to hold sum 2^32 distinct
 
947
    integers each <= 2^32.
 
948
  */
 
949
  if (table_field_type >= DRIZZLE_TYPE_TINY && table_field_type <= DRIZZLE_TYPE_LONG)
 
950
  {
 
951
    val.traits= Hybrid_type_traits_fast_decimal::instance();
 
952
    break;
 
953
  }
 
954
  table_field_type= DRIZZLE_TYPE_LONGLONG;
 
955
  /* fallthrough */
987
956
  case DECIMAL_RESULT:
988
957
    val.traits= Hybrid_type_traits_decimal::instance();
989
958
    if (table_field_type != DRIZZLE_TYPE_LONGLONG)
990
 
      table_field_type= DRIZZLE_TYPE_DECIMAL;
 
959
      table_field_type= DRIZZLE_TYPE_NEWDECIMAL;
991
960
    break;
992
961
  case ROW_RESULT:
 
962
  default:
993
963
    assert(0);
994
964
  }
995
 
 
996
965
  val.traits->fix_length_and_dec(this, args[0]);
997
966
}
998
967
 
999
968
 
1000
 
enum Item_result Item_sum_distinct::result_type () const
1001
 
{
1002
 
  return val.traits->type();
1003
 
}
1004
 
 
1005
 
 
1006
969
/**
1007
970
  @todo
1008
971
  check that the case of CHAR(0) works OK
1009
972
*/
1010
 
bool Item_sum_distinct::setup(Session *session)
 
973
bool Item_sum_distinct::setup(THD *thd)
1011
974
{
1012
 
  List<CreateField> field_list;
1013
 
  CreateField field_def;                              /* field definition */
 
975
  List<Create_field> field_list;
 
976
  Create_field field_def;                              /* field definition */
1014
977
  /* It's legal to call setup() more than once when in a subquery */
1015
978
  if (tree)
1016
979
    return(false);
1029
992
  assert(args[0]->fixed);
1030
993
 
1031
994
  field_def.init_for_tmp_table(table_field_type, args[0]->max_length,
1032
 
                               args[0]->decimals, args[0]->maybe_null);
 
995
                               args[0]->decimals, args[0]->maybe_null,
 
996
                               args[0]->unsigned_flag);
1033
997
 
1034
 
  if (! (table= session->getInstanceTable(field_list)))
 
998
  if (! (table= create_virtual_tmp_table(thd, field_list)))
1035
999
    return(true);
1036
1000
 
1037
1001
  /* XXX: check that the case of CHAR(0) works OK */
1038
 
  tree_key_length= table->getShare()->getRecordLength() - table->getShare()->null_bytes;
 
1002
  tree_key_length= table->s->reclength - table->s->null_bytes;
1039
1003
 
1040
1004
  /*
1041
1005
    Unique handles all unique elements in a tree until they can't fit
1043
1007
    simple_raw_key_cmp because the table contains numbers only; decimals
1044
1008
    are converted to binary representation as well.
1045
1009
  */
1046
 
  tree= new Unique(simple_raw_key_cmp, &tree_key_length,
1047
 
                   tree_key_length,
1048
 
                   (size_t)session->variables.max_heap_table_size);
 
1010
  tree= new Unique(simple_raw_key_cmp, &tree_key_length, tree_key_length,
 
1011
                   thd->variables.max_heap_table_size);
1049
1012
 
1050
1013
  is_evaluated= false;
1051
1014
  return(tree == 0);
1054
1017
 
1055
1018
bool Item_sum_distinct::add()
1056
1019
{
1057
 
  args[0]->save_in_field(table->getField(0), false);
 
1020
  args[0]->save_in_field(table->field[0], false);
1058
1021
  is_evaluated= false;
1059
 
  if (!table->getField(0)->is_null())
 
1022
  if (!table->field[0]->is_null())
1060
1023
  {
1061
1024
    assert(tree);
1062
1025
    null_value= 0;
1064
1027
      '0' values are also stored in the tree. This doesn't matter
1065
1028
      for SUM(DISTINCT), but is important for AVG(DISTINCT)
1066
1029
    */
1067
 
    return tree->unique_add(table->getField(0)->ptr);
 
1030
    return tree->unique_add(table->field[0]->ptr);
1068
1031
  }
1069
1032
  return 0;
1070
1033
}
1072
1035
 
1073
1036
bool Item_sum_distinct::unique_walk_function(void *element)
1074
1037
{
1075
 
  memcpy(table->getField(0)->ptr, element, tree_key_length);
 
1038
  memcpy(table->field[0]->ptr, element, tree_key_length);
1076
1039
  ++count;
1077
 
  val.traits->add(&val, table->getField(0));
 
1040
  val.traits->add(&val, table->field[0]);
1078
1041
  return 0;
1079
1042
}
1080
1043
 
1116
1079
     */
1117
1080
    if (tree)
1118
1081
    {
1119
 
      table->getField(0)->set_notnull();
 
1082
      table->field[0]->set_notnull();
1120
1083
      tree->walk(item_sum_distinct_walk, (void*) this);
1121
1084
    }
1122
1085
    is_evaluated= true;
1163
1126
Item_sum_avg_distinct::fix_length_and_dec()
1164
1127
{
1165
1128
  Item_sum_distinct::fix_length_and_dec();
1166
 
  prec_increment= current_session->variables.div_precincrement;
 
1129
  prec_increment= current_thd->variables.div_precincrement;
1167
1130
  /*
1168
1131
    AVG() will divide val by count. We need to reserve digits
1169
1132
    after decimal point as the result can be fractional.
1170
1133
  */
1171
 
  decimals= min(decimals + prec_increment, (unsigned int)NOT_FIXED_DEC);
 
1134
  decimals= cmin(decimals + prec_increment, (unsigned int)NOT_FIXED_DEC);
1172
1135
}
1173
1136
 
1174
1137
 
1185
1148
}
1186
1149
 
1187
1150
 
1188
 
Item *Item_sum_count::copy_or_same(Session* session)
 
1151
Item *Item_sum_count::copy_or_same(THD* thd)
1189
1152
{
1190
 
  return new (session->mem_root) Item_sum_count(session, this);
 
1153
  return new (thd->mem_root) Item_sum_count(thd, this);
1191
1154
}
1192
1155
 
1193
1156
 
1226
1189
{
1227
1190
  Item_sum_sum::fix_length_and_dec();
1228
1191
  maybe_null=null_value=1;
1229
 
  prec_increment= current_session->variables.div_precincrement;
 
1192
  prec_increment= current_thd->variables.div_precincrement;
1230
1193
  if (hybrid_type == DECIMAL_RESULT)
1231
1194
  {
1232
1195
    int precision= args[0]->decimal_precision() + prec_increment;
1233
 
    decimals= min(args[0]->decimals + prec_increment, (unsigned int) DECIMAL_MAX_SCALE);
 
1196
    decimals= cmin(args[0]->decimals + prec_increment, (unsigned int) DECIMAL_MAX_SCALE);
1234
1197
    max_length= my_decimal_precision_to_length(precision, decimals,
1235
1198
                                               unsigned_flag);
1236
 
    f_precision= min(precision+DECIMAL_LONGLONG_DIGITS, DECIMAL_MAX_PRECISION);
 
1199
    f_precision= cmin(precision+DECIMAL_LONGLONG_DIGITS, DECIMAL_MAX_PRECISION);
1237
1200
    f_scale=  args[0]->decimals;
1238
1201
    dec_bin_size= my_decimal_get_binary_size(f_precision, f_scale);
1239
1202
  }
1240
1203
  else {
1241
 
    decimals= min(args[0]->decimals + prec_increment, (unsigned int) NOT_FIXED_DEC);
 
1204
    decimals= cmin(args[0]->decimals + prec_increment, (unsigned int) NOT_FIXED_DEC);
1242
1205
    max_length= args[0]->max_length + prec_increment;
1243
1206
  }
1244
1207
}
1245
1208
 
1246
1209
 
1247
 
Item *Item_sum_avg::copy_or_same(Session* session)
 
1210
Item *Item_sum_avg::copy_or_same(THD* thd)
1248
1211
{
1249
 
  return new (session->mem_root) Item_sum_avg(session, this);
 
1212
  return new (thd->mem_root) Item_sum_avg(thd, this);
1250
1213
}
1251
1214
 
1252
1215
 
1253
1216
Field *Item_sum_avg::create_tmp_field(bool group, Table *table,
1254
 
                                      uint32_t )
 
1217
                                      uint32_t convert_blob_len __attribute__((unused)))
1255
1218
{
1256
1219
  Field *field;
1257
1220
  if (group)
1261
1224
      The easiest way is to do this is to store both value in a string
1262
1225
      and unpack on access.
1263
1226
    */
1264
 
    table->setVariableWidth();
1265
1227
    field= new Field_varstring(((hybrid_type == DECIMAL_RESULT) ?
1266
1228
                                dec_bin_size : sizeof(double)) + sizeof(int64_t),
1267
 
                               0, name, &my_charset_bin);
 
1229
                               0, name, table->s, &my_charset_bin);
1268
1230
  }
1269
1231
  else if (hybrid_type == DECIMAL_RESULT)
1270
 
    field= new Field_decimal(max_length, maybe_null, name,
1271
 
                             decimals, unsigned_flag);
 
1232
    field= new Field_new_decimal(max_length, maybe_null, name,
 
1233
                                 decimals, unsigned_flag);
1272
1234
  else
1273
1235
    field= new Field_double(max_length, maybe_null, name, decimals, true);
1274
1236
  if (field)
1305
1267
}
1306
1268
 
1307
1269
 
1308
 
int64_t Item_sum_avg::val_int()
1309
 
{
1310
 
  return (int64_t) rint(val_real());
1311
 
}
1312
 
 
1313
 
 
1314
1270
my_decimal *Item_sum_avg::val_decimal(my_decimal *val)
1315
1271
{
1316
1272
  my_decimal sum_buff, cnt;
1356
1312
  return sqrt(nr);
1357
1313
}
1358
1314
 
1359
 
Item *Item_sum_std::copy_or_same(Session* session)
 
1315
Item *Item_sum_std::copy_or_same(THD* thd)
1360
1316
{
1361
 
  return new (session->mem_root) Item_sum_std(session, this);
 
1317
  return new (thd->mem_root) Item_sum_std(thd, this);
1362
1318
}
1363
1319
 
1364
1320
 
1383
1339
{
1384
1340
  *count += 1;
1385
1341
 
1386
 
  if (*count == 1)
 
1342
  if (*count == 1) 
1387
1343
  {
1388
1344
    *m= nr;
1389
1345
    *s= 0;
1410
1366
}
1411
1367
 
1412
1368
 
1413
 
Item_sum_variance::Item_sum_variance(Session *session, Item_sum_variance *item):
1414
 
  Item_sum_num(session, item), hybrid_type(item->hybrid_type),
 
1369
Item_sum_variance::Item_sum_variance(THD *thd, Item_sum_variance *item):
 
1370
  Item_sum_num(thd, item), hybrid_type(item->hybrid_type),
1415
1371
    count(item->count), sample(item->sample),
1416
1372
    prec_increment(item->prec_increment)
1417
1373
{
1423
1379
void Item_sum_variance::fix_length_and_dec()
1424
1380
{
1425
1381
  maybe_null= null_value= 1;
1426
 
  prec_increment= current_session->variables.div_precincrement;
 
1382
  prec_increment= current_thd->variables.div_precincrement;
1427
1383
 
1428
1384
  /*
1429
1385
    According to the SQL2003 standard (Part 2, Foundations; sec 10.9,
1430
 
    aggregate function; paragraph 7h of Syntax Rules), "the declared
 
1386
    aggregate function; paragraph 7h of Syntax Rules), "the declared 
1431
1387
    type of the result is an implementation-defined aproximate numeric
1432
1388
    type.
1433
1389
  */
1436
1392
  switch (args[0]->result_type()) {
1437
1393
  case REAL_RESULT:
1438
1394
  case STRING_RESULT:
1439
 
    decimals= min(args[0]->decimals + 4, (int)NOT_FIXED_DEC);
 
1395
    decimals= cmin(args[0]->decimals + 4, NOT_FIXED_DEC);
1440
1396
    break;
1441
1397
  case INT_RESULT:
1442
1398
  case DECIMAL_RESULT:
1443
 
    {
1444
 
      int precision= args[0]->decimal_precision()*2 + prec_increment;
1445
 
      decimals= min(args[0]->decimals + prec_increment, (unsigned int) DECIMAL_MAX_SCALE);
1446
 
      max_length= my_decimal_precision_to_length(precision, decimals,
1447
 
                                                 unsigned_flag);
 
1399
  {
 
1400
    int precision= args[0]->decimal_precision()*2 + prec_increment;
 
1401
    decimals= cmin(args[0]->decimals + prec_increment, (unsigned int) DECIMAL_MAX_SCALE);
 
1402
    max_length= my_decimal_precision_to_length(precision, decimals,
 
1403
                                               unsigned_flag);
1448
1404
 
1449
 
      break;
1450
 
    }
 
1405
    break;
 
1406
  }
1451
1407
  case ROW_RESULT:
 
1408
  default:
1452
1409
    assert(0);
1453
1410
  }
 
1411
  return;
1454
1412
}
1455
1413
 
1456
1414
 
1457
 
Item *Item_sum_variance::copy_or_same(Session* session)
 
1415
Item *Item_sum_variance::copy_or_same(THD* thd)
1458
1416
{
1459
 
  return new (session->mem_root) Item_sum_variance(session, this);
 
1417
  return new (thd->mem_root) Item_sum_variance(thd, this);
1460
1418
}
1461
1419
 
1462
1420
 
1466
1424
  pass around.
1467
1425
*/
1468
1426
Field *Item_sum_variance::create_tmp_field(bool group, Table *table,
1469
 
                                           uint32_t )
 
1427
                                           uint32_t convert_blob_len __attribute__((unused)))
1470
1428
{
1471
1429
  Field *field;
1472
1430
  if (group)
1476
1434
      The easiest way is to do this is to store both value in a string
1477
1435
      and unpack on access.
1478
1436
    */
1479
 
    table->setVariableWidth();
1480
 
    field= new Field_varstring(sizeof(double)*2 + sizeof(int64_t), 0, name, &my_charset_bin);
 
1437
    field= new Field_varstring(sizeof(double)*2 + sizeof(int64_t), 0, name, table->s, &my_charset_bin);
1481
1438
  }
1482
1439
  else
1483
1440
    field= new Field_double(max_length, maybe_null, name, decimals, true);
1491
1448
 
1492
1449
void Item_sum_variance::clear()
1493
1450
{
1494
 
  count= 0;
 
1451
  count= 0; 
1495
1452
}
1496
1453
 
1497
1454
bool Item_sum_variance::add()
1498
1455
{
1499
 
  /*
 
1456
  /* 
1500
1457
    Why use a temporary variable?  We don't know if it is null until we
1501
1458
    evaluate it, which has the side-effect of setting null_value .
1502
1459
  */
1503
1460
  double nr= args[0]->val_real();
1504
 
 
 
1461
  
1505
1462
  if (!args[0]->null_value)
1506
1463
    variance_fp_recurrence_next(&recurrence_m, &recurrence_s, &count, nr);
1507
1464
  return 0;
1532
1489
}
1533
1490
 
1534
1491
 
1535
 
int64_t Item_sum_variance::val_int()
1536
 
{
1537
 
  /* can't be fix_fields()ed */
1538
 
  return (int64_t) rint(val_real());
1539
 
}
1540
 
 
1541
 
 
1542
1492
my_decimal *Item_sum_variance::val_decimal(my_decimal *dec_buf)
1543
1493
{
1544
1494
  assert(fixed == 1);
1619
1569
  assert(fixed == 1);
1620
1570
  if (null_value)
1621
1571
    return 0.0;
1622
 
 
1623
1572
  switch (hybrid_type) {
1624
1573
  case STRING_RESULT:
1625
 
    {
1626
 
      char *end_not_used;
1627
 
      int err_not_used;
1628
 
      String *res;  res=val_str(&str_value);
1629
 
      return (res ? my_strntod(res->charset(), (char*) res->ptr(), res->length(),
1630
 
                               &end_not_used, &err_not_used) : 0.0);
1631
 
    }
 
1574
  {
 
1575
    char *end_not_used;
 
1576
    int err_not_used;
 
1577
    String *res;  res=val_str(&str_value);
 
1578
    return (res ? my_strntod(res->charset(), (char*) res->ptr(), res->length(),
 
1579
                             &end_not_used, &err_not_used) : 0.0);
 
1580
  }
1632
1581
  case INT_RESULT:
 
1582
    if (unsigned_flag)
 
1583
      return uint64_t2double(sum_int);
1633
1584
    return (double) sum_int;
1634
1585
  case DECIMAL_RESULT:
1635
1586
    my_decimal2double(E_DEC_FATAL_ERROR, &sum_dec, &sum);
1637
1588
  case REAL_RESULT:
1638
1589
    return sum;
1639
1590
  case ROW_RESULT:
 
1591
  default:
1640
1592
    // This case should never be choosen
1641
 
    break;
 
1593
    assert(0);
 
1594
    return 0;
1642
1595
  }
1643
 
 
1644
 
  assert(0);
1645
 
  return 0;
1646
1596
}
1647
1597
 
1648
1598
int64_t Item_sum_hybrid::val_int()
1670
1620
  assert(fixed == 1);
1671
1621
  if (null_value)
1672
1622
    return 0;
1673
 
 
1674
1623
  switch (hybrid_type) {
1675
1624
  case STRING_RESULT:
1676
1625
    string2my_decimal(E_DEC_FATAL_ERROR, &value, val);
1685
1634
    int2my_decimal(E_DEC_FATAL_ERROR, sum_int, unsigned_flag, val);
1686
1635
    break;
1687
1636
  case ROW_RESULT:
 
1637
  default:
1688
1638
    // This case should never be choosen
1689
1639
    assert(0);
1690
1640
    break;
1691
1641
  }
1692
 
 
1693
1642
  return val;                                   // Keep compiler happy
1694
1643
}
1695
1644
 
1700
1649
  assert(fixed == 1);
1701
1650
  if (null_value)
1702
1651
    return 0;
1703
 
 
1704
1652
  switch (hybrid_type) {
1705
1653
  case STRING_RESULT:
1706
1654
    return &value;
1716
1664
  case ROW_RESULT:
1717
1665
  default:
1718
1666
    // This case should never be choosen
 
1667
    assert(0);
1719
1668
    break;
1720
1669
  }
1721
 
 
1722
1670
  return str;                                   // Keep compiler happy
1723
1671
}
1724
1672
 
1746
1694
}
1747
1695
 
1748
1696
 
1749
 
Item *Item_sum_min::copy_or_same(Session* session)
 
1697
Item *Item_sum_min::copy_or_same(THD* thd)
1750
1698
{
1751
 
  return new (session->mem_root) Item_sum_min(session, this);
 
1699
  return new (thd->mem_root) Item_sum_min(thd, this);
1752
1700
}
1753
1701
 
1754
1702
 
1756
1704
{
1757
1705
  switch (hybrid_type) {
1758
1706
  case STRING_RESULT:
 
1707
  {
 
1708
    String *result=args[0]->val_str(&tmp_value);
 
1709
    if (!args[0]->null_value &&
 
1710
        (null_value || sortcmp(&value,result,collation.collation) > 0))
1759
1711
    {
1760
 
      String *result=args[0]->val_str(&tmp_value);
1761
 
      if (!args[0]->null_value &&
1762
 
          (null_value || sortcmp(&value,result,collation.collation) > 0))
1763
 
      {
1764
 
        value.copy(*result);
1765
 
        null_value=0;
1766
 
      }
 
1712
      value.copy(*result);
 
1713
      null_value=0;
1767
1714
    }
1768
 
    break;
 
1715
  }
 
1716
  break;
1769
1717
  case INT_RESULT:
 
1718
  {
 
1719
    int64_t nr=args[0]->val_int();
 
1720
    if (!args[0]->null_value && (null_value ||
 
1721
                                 (unsigned_flag && 
 
1722
                                  (uint64_t) nr < (uint64_t) sum_int) ||
 
1723
                                 (!unsigned_flag && nr < sum_int)))
1770
1724
    {
1771
 
      int64_t nr=args[0]->val_int();
1772
 
      if (!args[0]->null_value && (null_value ||
1773
 
                                   (unsigned_flag &&
1774
 
                                    (uint64_t) nr < (uint64_t) sum_int) ||
1775
 
                                   (!unsigned_flag && nr < sum_int)))
1776
 
      {
1777
 
        sum_int=nr;
1778
 
        null_value=0;
1779
 
      }
 
1725
      sum_int=nr;
 
1726
      null_value=0;
1780
1727
    }
1781
 
    break;
 
1728
  }
 
1729
  break;
1782
1730
  case DECIMAL_RESULT:
 
1731
  {
 
1732
    my_decimal value_buff, *val= args[0]->val_decimal(&value_buff);
 
1733
    if (!args[0]->null_value &&
 
1734
        (null_value || (my_decimal_cmp(&sum_dec, val) > 0)))
1783
1735
    {
1784
 
      my_decimal value_buff, *val= args[0]->val_decimal(&value_buff);
1785
 
      if (!args[0]->null_value &&
1786
 
          (null_value || (my_decimal_cmp(&sum_dec, val) > 0)))
1787
 
      {
1788
 
        my_decimal2decimal(val, &sum_dec);
1789
 
        null_value= 0;
1790
 
      }
 
1736
      my_decimal2decimal(val, &sum_dec);
 
1737
      null_value= 0;
1791
1738
    }
1792
 
    break;
 
1739
  }
 
1740
  break;
1793
1741
  case REAL_RESULT:
 
1742
  {
 
1743
    double nr= args[0]->val_real();
 
1744
    if (!args[0]->null_value && (null_value || nr < sum))
1794
1745
    {
1795
 
      double nr= args[0]->val_real();
1796
 
      if (!args[0]->null_value && (null_value || nr < sum))
1797
 
      {
1798
 
        sum=nr;
1799
 
        null_value=0;
1800
 
      }
 
1746
      sum=nr;
 
1747
      null_value=0;
1801
1748
    }
1802
 
    break;
 
1749
  }
 
1750
  break;
1803
1751
  case ROW_RESULT:
 
1752
  default:
1804
1753
    // This case should never be choosen
1805
1754
    assert(0);
1806
1755
    break;
1809
1758
}
1810
1759
 
1811
1760
 
1812
 
Item *Item_sum_max::copy_or_same(Session* session)
 
1761
Item *Item_sum_max::copy_or_same(THD* thd)
1813
1762
{
1814
 
  return new (session->mem_root) Item_sum_max(session, this);
 
1763
  return new (thd->mem_root) Item_sum_max(thd, this);
1815
1764
}
1816
1765
 
1817
1766
 
1819
1768
{
1820
1769
  switch (hybrid_type) {
1821
1770
  case STRING_RESULT:
 
1771
  {
 
1772
    String *result=args[0]->val_str(&tmp_value);
 
1773
    if (!args[0]->null_value &&
 
1774
        (null_value || sortcmp(&value,result,collation.collation) < 0))
1822
1775
    {
1823
 
      String *result=args[0]->val_str(&tmp_value);
1824
 
      if (!args[0]->null_value &&
1825
 
          (null_value || sortcmp(&value,result,collation.collation) < 0))
1826
 
      {
1827
 
        value.copy(*result);
1828
 
        null_value=0;
1829
 
      }
 
1776
      value.copy(*result);
 
1777
      null_value=0;
1830
1778
    }
1831
 
    break;
 
1779
  }
 
1780
  break;
1832
1781
  case INT_RESULT:
 
1782
  {
 
1783
    int64_t nr=args[0]->val_int();
 
1784
    if (!args[0]->null_value && (null_value ||
 
1785
                                 (unsigned_flag && 
 
1786
                                  (uint64_t) nr > (uint64_t) sum_int) ||
 
1787
                                 (!unsigned_flag && nr > sum_int)))
1833
1788
    {
1834
 
      int64_t nr=args[0]->val_int();
1835
 
      if (!args[0]->null_value && (null_value ||
1836
 
                                   (unsigned_flag &&
1837
 
                                    (uint64_t) nr > (uint64_t) sum_int) ||
1838
 
                                   (!unsigned_flag && nr > sum_int)))
1839
 
      {
1840
 
        sum_int=nr;
1841
 
        null_value=0;
1842
 
      }
 
1789
      sum_int=nr;
 
1790
      null_value=0;
1843
1791
    }
1844
 
    break;
 
1792
  }
 
1793
  break;
1845
1794
  case DECIMAL_RESULT:
 
1795
  {
 
1796
    my_decimal value_buff, *val= args[0]->val_decimal(&value_buff);
 
1797
    if (!args[0]->null_value &&
 
1798
        (null_value || (my_decimal_cmp(val, &sum_dec) > 0)))
1846
1799
    {
1847
 
      my_decimal value_buff, *val= args[0]->val_decimal(&value_buff);
1848
 
      if (!args[0]->null_value &&
1849
 
          (null_value || (my_decimal_cmp(val, &sum_dec) > 0)))
1850
 
      {
1851
 
        my_decimal2decimal(val, &sum_dec);
1852
 
        null_value= 0;
1853
 
      }
 
1800
      my_decimal2decimal(val, &sum_dec);
 
1801
      null_value= 0;
1854
1802
    }
1855
 
    break;
 
1803
  }
 
1804
  break;
1856
1805
  case REAL_RESULT:
 
1806
  {
 
1807
    double nr= args[0]->val_real();
 
1808
    if (!args[0]->null_value && (null_value || nr > sum))
1857
1809
    {
1858
 
      double nr= args[0]->val_real();
1859
 
      if (!args[0]->null_value && (null_value || nr > sum))
1860
 
      {
1861
 
        sum=nr;
1862
 
        null_value=0;
1863
 
      }
 
1810
      sum=nr;
 
1811
      null_value=0;
1864
1812
    }
1865
 
    break;
 
1813
  }
 
1814
  break;
1866
1815
  case ROW_RESULT:
 
1816
  default:
1867
1817
    // This case should never be choosen
1868
1818
    assert(0);
1869
1819
    break;
1870
1820
  }
1871
 
 
1872
1821
  return 0;
1873
1822
}
1874
1823
 
1887
1836
  bits= reset_bits;
1888
1837
}
1889
1838
 
1890
 
Item *Item_sum_or::copy_or_same(Session* session)
 
1839
Item *Item_sum_or::copy_or_same(THD* thd)
1891
1840
{
1892
 
  return new (session->mem_root) Item_sum_or(session, this);
 
1841
  return new (thd->mem_root) Item_sum_or(thd, this);
1893
1842
}
1894
1843
 
1895
1844
 
1901
1850
  return 0;
1902
1851
}
1903
1852
 
1904
 
Item *Item_sum_xor::copy_or_same(Session* session)
 
1853
Item *Item_sum_xor::copy_or_same(THD* thd)
1905
1854
{
1906
 
  return new (session->mem_root) Item_sum_xor(session, this);
 
1855
  return new (thd->mem_root) Item_sum_xor(thd, this);
1907
1856
}
1908
1857
 
1909
1858
 
1915
1864
  return 0;
1916
1865
}
1917
1866
 
1918
 
Item *Item_sum_and::copy_or_same(Session* session)
 
1867
Item *Item_sum_and::copy_or_same(THD* thd)
1919
1868
{
1920
 
  return new (session->mem_root) Item_sum_and(session, this);
 
1869
  return new (thd->mem_root) Item_sum_and(thd, this);
1921
1870
}
1922
1871
 
1923
1872
 
1956
1905
{
1957
1906
  switch(hybrid_type) {
1958
1907
  case STRING_RESULT:
1959
 
    {
1960
 
      char buff[MAX_FIELD_WIDTH];
1961
 
      String tmp(buff,sizeof(buff),result_field->charset()),*res;
1962
 
 
1963
 
      res=args[0]->val_str(&tmp);
1964
 
      if (args[0]->null_value)
1965
 
      {
 
1908
  {
 
1909
    char buff[MAX_FIELD_WIDTH];
 
1910
    String tmp(buff,sizeof(buff),result_field->charset()),*res;
 
1911
 
 
1912
    res=args[0]->val_str(&tmp);
 
1913
    if (args[0]->null_value)
 
1914
    {
 
1915
      result_field->set_null();
 
1916
      result_field->reset();
 
1917
    }
 
1918
    else
 
1919
    {
 
1920
      result_field->set_notnull();
 
1921
      result_field->store(res->ptr(),res->length(),tmp.charset());
 
1922
    }
 
1923
    break;
 
1924
  }
 
1925
  case INT_RESULT:
 
1926
  {
 
1927
    int64_t nr=args[0]->val_int();
 
1928
 
 
1929
    if (maybe_null)
 
1930
    {
 
1931
      if (args[0]->null_value)
 
1932
      {
 
1933
        nr=0;
 
1934
        result_field->set_null();
 
1935
      }
 
1936
      else
 
1937
        result_field->set_notnull();
 
1938
    }
 
1939
    result_field->store(nr, unsigned_flag);
 
1940
    break;
 
1941
  }
 
1942
  case REAL_RESULT:
 
1943
  {
 
1944
    double nr= args[0]->val_real();
 
1945
 
 
1946
    if (maybe_null)
 
1947
    {
 
1948
      if (args[0]->null_value)
 
1949
      {
 
1950
        nr=0.0;
 
1951
        result_field->set_null();
 
1952
      }
 
1953
      else
 
1954
        result_field->set_notnull();
 
1955
    }
 
1956
    result_field->store(nr);
 
1957
    break;
 
1958
  }
 
1959
  case DECIMAL_RESULT:
 
1960
  {
 
1961
    my_decimal value_buff, *arg_dec= args[0]->val_decimal(&value_buff);
 
1962
 
 
1963
    if (maybe_null)
 
1964
    {
 
1965
      if (args[0]->null_value)
1966
1966
        result_field->set_null();
1967
 
        result_field->reset();
1968
 
      }
1969
1967
      else
1970
 
      {
1971
1968
        result_field->set_notnull();
1972
 
        result_field->store(res->ptr(),res->length(),tmp.charset());
1973
 
      }
1974
 
      break;
1975
 
    }
1976
 
  case INT_RESULT:
1977
 
    {
1978
 
      int64_t nr=args[0]->val_int();
1979
 
 
1980
 
      if (maybe_null)
1981
 
      {
1982
 
        if (args[0]->null_value)
1983
 
        {
1984
 
          nr=0;
1985
 
          result_field->set_null();
1986
 
        }
1987
 
        else
1988
 
          result_field->set_notnull();
1989
 
      }
1990
 
      result_field->store(nr, unsigned_flag);
1991
 
      break;
1992
 
    }
1993
 
  case REAL_RESULT:
1994
 
    {
1995
 
      double nr= args[0]->val_real();
1996
 
 
1997
 
      if (maybe_null)
1998
 
      {
1999
 
        if (args[0]->null_value)
2000
 
        {
2001
 
          nr=0.0;
2002
 
          result_field->set_null();
2003
 
        }
2004
 
        else
2005
 
          result_field->set_notnull();
2006
 
      }
2007
 
      result_field->store(nr);
2008
 
      break;
2009
 
    }
2010
 
  case DECIMAL_RESULT:
2011
 
    {
2012
 
      my_decimal value_buff, *arg_dec= args[0]->val_decimal(&value_buff);
2013
 
 
2014
 
      if (maybe_null)
2015
 
      {
2016
 
        if (args[0]->null_value)
2017
 
          result_field->set_null();
2018
 
        else
2019
 
          result_field->set_notnull();
2020
 
      }
2021
 
      /*
2022
 
        We must store zero in the field as we will use the field value in
2023
 
        add()
2024
 
      */
2025
 
      if (!arg_dec)                               // Null
2026
 
        arg_dec= &decimal_zero;
2027
 
      result_field->store_decimal(arg_dec);
2028
 
      break;
2029
 
    }
 
1969
    }
 
1970
    /*
 
1971
      We must store zero in the field as we will use the field value in
 
1972
      add()
 
1973
    */
 
1974
    if (!arg_dec)                               // Null
 
1975
      arg_dec= &decimal_zero;
 
1976
    result_field->store_decimal(arg_dec);
 
1977
    break;
 
1978
  }
2030
1979
  case ROW_RESULT:
 
1980
  default:
2031
1981
    assert(0);
2032
1982
  }
2033
1983
}
2222
2172
  case DECIMAL_RESULT:
2223
2173
    min_max_update_decimal_field();
2224
2174
    break;
2225
 
  case REAL_RESULT:
2226
 
  case ROW_RESULT:
 
2175
  default:
2227
2176
    min_max_update_real_field();
2228
2177
  }
2229
2178
}
2236
2185
 
2237
2186
  if (!args[0]->null_value)
2238
2187
  {
2239
 
    result_field->val_str_internal(&tmp_value);
 
2188
    result_field->val_str(&tmp_value);
2240
2189
 
2241
2190
    if (result_field->is_null() ||
2242
2191
        (cmp_sign * sortcmp(res_str,&tmp_value,collation.collation)) < 0)
2458
2407
}
2459
2408
 
2460
2409
 
2461
 
int64_t Item_variance_field::val_int()
2462
 
{
2463
 
  /* can't be fix_fields()ed */
2464
 
  return (int64_t) rint(val_real());
2465
 
}
2466
 
 
2467
 
 
2468
2410
double Item_variance_field::val_real()
2469
2411
{
2470
2412
  // fix_fields() never calls for this Item
2503
2445
int composite_key_cmp(void* arg, unsigned char* key1, unsigned char* key2)
2504
2446
{
2505
2447
  Item_sum_count_distinct* item = (Item_sum_count_distinct*)arg;
2506
 
  Field **field    = item->table->getFields();
2507
 
  Field **field_end= field + item->table->getShare()->sizeFields();
 
2448
  Field **field    = item->table->field;
 
2449
  Field **field_end= field + item->table->s->fields;
2508
2450
  uint32_t *lengths=item->field_lengths;
2509
2451
  for (; field < field_end; ++field)
2510
2452
  {
2519
2461
  return 0;
2520
2462
}
2521
2463
 
2522
 
static int count_distinct_walk(void *,
2523
 
                               uint32_t ,
 
2464
#ifdef __cplusplus
 
2465
extern "C" {
 
2466
#endif
 
2467
 
 
2468
static int count_distinct_walk(void *elem __attribute__((unused)),
 
2469
                               element_count count __attribute__((unused)),
2524
2470
                               void *arg)
2525
2471
{
2526
2472
  (*((uint64_t*)arg))++;
2527
2473
  return 0;
2528
2474
}
2529
2475
 
 
2476
#ifdef __cplusplus
 
2477
}
 
2478
#endif
 
2479
 
 
2480
 
 
2481
 
2530
2482
void Item_sum_count_distinct::cleanup()
2531
2483
{
2532
2484
  Item_sum_int::cleanup();
2544
2496
    is_evaluated= false;
2545
2497
    if (table)
2546
2498
    {
 
2499
      table->free_tmp_table(table->in_use);
2547
2500
      table= 0;
2548
2501
    }
2549
2502
    delete tmp_table_param;
2577
2530
}
2578
2531
 
2579
2532
 
2580
 
bool Item_sum_count_distinct::setup(Session *session)
 
2533
bool Item_sum_count_distinct::setup(THD *thd)
2581
2534
{
2582
2535
  List<Item> list;
2583
 
  Select_Lex *select_lex= session->lex->current_select;
 
2536
  SELECT_LEX *select_lex= thd->lex->current_select;
2584
2537
 
2585
2538
  /*
2586
2539
    Setup can be called twice for ROLLUP items. This is a bug.
2590
2543
  if (tree || table || tmp_table_param)
2591
2544
    return false;
2592
2545
 
2593
 
  if (!(tmp_table_param= new Tmp_Table_Param))
 
2546
  if (!(tmp_table_param= new TMP_TABLE_PARAM))
2594
2547
    return true;
2595
2548
 
2596
2549
  /* Create a table with an unique key over all parameters */
2608
2561
  tmp_table_param->force_copy_fields= force_copy_fields;
2609
2562
  assert(table == 0);
2610
2563
 
2611
 
  if (!(table= create_tmp_table(session, tmp_table_param, list, (Order*) 0, 1,
 
2564
  if (!(table= create_tmp_table(thd, tmp_table_param, list, (order_st*) 0, 1,
2612
2565
                                0,
2613
 
                                (select_lex->options | session->options),
 
2566
                                (select_lex->options | thd->options),
2614
2567
                                HA_POS_ERROR, (char*)"")))
2615
 
  {
2616
2568
    return true;
2617
 
  }
2618
 
  table->cursor->extra(HA_EXTRA_NO_ROWS);               // Don't update rows
 
2569
  table->file->extra(HA_EXTRA_NO_ROWS);         // Don't update rows
2619
2570
  table->no_rows=1;
2620
2571
 
2621
 
  if (table->getShare()->db_type() == heap_engine)
 
2572
  if (table->s->db_type() == heap_hton)
2622
2573
  {
2623
2574
    /*
2624
2575
      No blobs, otherwise it would have been MyISAM: set up a compare
2626
2577
    */
2627
2578
    qsort_cmp2 compare_key;
2628
2579
    void* cmp_arg;
2629
 
    Field **field= table->getFields();
2630
 
    Field **field_end= field + table->getShare()->sizeFields();
 
2580
    Field **field= table->field;
 
2581
    Field **field_end= field + table->s->fields;
2631
2582
    bool all_binary= true;
2632
2583
 
2633
2584
    for (tree_key_length= 0; field < field_end; ++field)
2648
2599
    }
2649
2600
    else
2650
2601
    {
2651
 
      if (table->getShare()->sizeFields() == 1)
 
2602
      if (table->s->fields == 1)
2652
2603
      {
2653
2604
        /*
2654
2605
          If we have only one field, which is the most common use of
2657
2608
          about other fields.
2658
2609
        */
2659
2610
        compare_key= (qsort_cmp2) simple_str_key_cmp;
2660
 
        cmp_arg= (void*) table->getField(0);
 
2611
        cmp_arg= (void*) table->field[0];
2661
2612
        /* tree_key_length has been set already */
2662
2613
      }
2663
2614
      else
2665
2616
        uint32_t *length;
2666
2617
        compare_key= (qsort_cmp2) composite_key_cmp;
2667
2618
        cmp_arg= (void*) this;
2668
 
        field_lengths= (uint32_t*) session->alloc(table->getShare()->sizeFields() * sizeof(uint32_t));
2669
 
        for (tree_key_length= 0, length= field_lengths, field= table->getFields();
 
2619
        field_lengths= (uint32_t*) thd->alloc(table->s->fields * sizeof(uint32_t));
 
2620
        for (tree_key_length= 0, length= field_lengths, field= table->field;
2670
2621
             field < field_end; ++field, ++length)
2671
2622
        {
2672
2623
          *length= (*field)->pack_length();
2676
2627
    }
2677
2628
    assert(tree == 0);
2678
2629
    tree= new Unique(compare_key, cmp_arg, tree_key_length,
2679
 
                     (size_t)session->variables.max_heap_table_size);
 
2630
                     thd->variables.max_heap_table_size);
2680
2631
    /*
2681
2632
      The only time tree_key_length could be 0 is if someone does
2682
2633
      count(distinct) on a char(0) field - stupid thing to do,
2691
2642
}
2692
2643
 
2693
2644
 
2694
 
Item *Item_sum_count_distinct::copy_or_same(Session* session)
 
2645
Item *Item_sum_count_distinct::copy_or_same(THD* thd) 
2695
2646
{
2696
 
  return new (session->mem_root) Item_sum_count_distinct(session, this);
 
2647
  return new (thd->mem_root) Item_sum_count_distinct(thd, this);
2697
2648
}
2698
2649
 
2699
2650
 
2707
2658
  }
2708
2659
  else if (table)
2709
2660
  {
2710
 
    table->cursor->extra(HA_EXTRA_NO_CACHE);
2711
 
    table->cursor->ha_delete_all_rows();
2712
 
    table->cursor->extra(HA_EXTRA_WRITE_CACHE);
 
2661
    table->file->extra(HA_EXTRA_NO_CACHE);
 
2662
    table->file->ha_delete_all_rows();
 
2663
    table->file->extra(HA_EXTRA_WRITE_CACHE);
2713
2664
  }
2714
2665
}
2715
2666
 
2719
2670
  if (always_null)
2720
2671
    return 0;
2721
2672
  copy_fields(tmp_table_param);
2722
 
  if (copy_funcs(tmp_table_param->items_to_copy, table->in_use))
2723
 
    return true;
 
2673
  copy_funcs(tmp_table_param->items_to_copy);
2724
2674
 
2725
 
  for (Field **field= table->getFields() ; *field ; field++)
2726
 
  {
 
2675
  for (Field **field=table->field ; *field ; field++)
2727
2676
    if ((*field)->is_real_null(0))
2728
 
    {
2729
2677
      return 0;                                 // Don't count NULL
2730
 
    }
2731
 
  }
2732
2678
 
2733
2679
  is_evaluated= false;
2734
2680
  if (tree)
2739
2685
      bloat the tree without providing any valuable info. Besides,
2740
2686
      key_length used to initialize the tree didn't include space for them.
2741
2687
    */
2742
 
    return tree->unique_add(table->record[0] + table->getShare()->null_bytes);
 
2688
    return tree->unique_add(table->record[0] + table->s->null_bytes);
2743
2689
  }
2744
 
  if ((error= table->cursor->insertRecord(table->record[0])) &&
2745
 
      table->cursor->is_fatal_error(error, HA_CHECK_DUP))
 
2690
  if ((error= table->file->ha_write_row(table->record[0])) &&
 
2691
      table->file->is_fatal_error(error, HA_CHECK_DUP))
2746
2692
    return true;
2747
2693
  return false;
2748
2694
}
2767
2713
    return (int64_t) count;
2768
2714
  }
2769
2715
 
2770
 
  error= table->cursor->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
 
2716
  error= table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
2771
2717
 
2772
2718
  if(error)
2773
2719
  {
2774
 
    table->print_error(error, MYF(0));
 
2720
    table->file->print_error(error, MYF(0));
2775
2721
  }
2776
2722
 
2777
 
  return table->cursor->stats.records;
 
2723
  return table->file->stats.records;
2778
2724
}
2779
2725
 
2780
2726
/*****************************************************************************
2791
2737
*****************************************************************************/
2792
2738
 
2793
2739
 
2794
 
/**
 
2740
/** 
2795
2741
  Compares the values for fields in expr list of GROUP_CONCAT.
2796
2742
  @note
2797
 
 
 
2743
       
2798
2744
     GROUP_CONCAT([DISTINCT] expr [,expr ...]
2799
2745
              [order_st BY {unsigned_integer | col_name | expr}
2800
2746
                  [ASC | DESC] [,col_name ...]]
2801
2747
              [SEPARATOR str_val])
2802
 
 
 
2748
 
2803
2749
  @return
2804
 
  @retval -1 : key1 < key2
 
2750
  @retval -1 : key1 < key2 
2805
2751
  @retval  0 : key1 = key2
2806
 
  @retval  1 : key1 > key2
 
2752
  @retval  1 : key1 > key2 
2807
2753
*/
2808
2754
 
2809
 
int group_concat_key_cmp_with_distinct(void* arg, const void* key1,
 
2755
int group_concat_key_cmp_with_distinct(void* arg, const void* key1, 
2810
2756
                                       const void* key2)
2811
2757
{
2812
2758
  Item_func_group_concat *item_func= (Item_func_group_concat*)arg;
2815
2761
  for (uint32_t i= 0; i < item_func->arg_count_field; i++)
2816
2762
  {
2817
2763
    Item *item= item_func->args[i];
2818
 
    /*
 
2764
    /* 
2819
2765
      If field_item is a const item then either get_tp_table_field returns 0
2820
 
      or it is an item over a const table.
 
2766
      or it is an item over a const table. 
2821
2767
    */
2822
2768
    if (item->const_item())
2823
2769
      continue;
2828
2774
    */
2829
2775
    Field *field= item->get_tmp_table_field();
2830
2776
    int res;
2831
 
    uint32_t offset= field->offset(field->getTable()->record[0])-table->getShare()->null_bytes;
 
2777
    uint32_t offset= field->offset(field->table->record[0])-table->s->null_bytes;
2832
2778
    if((res= field->cmp((unsigned char*)key1 + offset, (unsigned char*)key2 + offset)))
2833
2779
      return res;
2834
2780
  }
2837
2783
 
2838
2784
 
2839
2785
/**
2840
 
  function of sort for syntax: GROUP_CONCAT(expr,... ORDER BY col,... )
 
2786
  function of sort for syntax: GROUP_CONCAT(expr,... order_st BY col,... )
2841
2787
*/
2842
2788
 
2843
 
int group_concat_key_cmp_with_order(void* arg, const void* key1,
 
2789
int group_concat_key_cmp_with_order(void* arg, const void* key1, 
2844
2790
                                    const void* key2)
2845
2791
{
2846
2792
  Item_func_group_concat* grp_item= (Item_func_group_concat*) arg;
2847
 
  Order **order_item, **end;
 
2793
  order_st **order_item, **end;
2848
2794
  Table *table= grp_item->table;
2849
2795
 
2850
2796
  for (order_item= grp_item->order, end=order_item+ grp_item->arg_count_order;
2858
2804
      the temporary table, not the original field
2859
2805
    */
2860
2806
    Field *field= item->get_tmp_table_field();
2861
 
    /*
 
2807
    /* 
2862
2808
      If item is a const item then either get_tp_table_field returns 0
2863
 
      or it is an item over a const table.
 
2809
      or it is an item over a const table. 
2864
2810
    */
2865
2811
    if (field && !item->const_item())
2866
2812
    {
2867
2813
      int res;
2868
 
      uint32_t offset= (field->offset(field->getTable()->record[0]) -
2869
 
                    table->getShare()->null_bytes);
 
2814
      uint32_t offset= (field->offset(field->table->record[0]) -
 
2815
                    table->s->null_bytes);
2870
2816
      if ((res= field->cmp((unsigned char*)key1 + offset, (unsigned char*)key2 + offset)))
2871
2817
        return (*order_item)->asc ? res : -res;
2872
2818
    }
2884
2830
  Append data from current leaf to item->result.
2885
2831
*/
2886
2832
 
2887
 
int dump_leaf_key(unsigned char* key, uint32_t ,
 
2833
int dump_leaf_key(unsigned char* key, element_count count __attribute__((unused)),
2888
2834
                  Item_func_group_concat *item)
2889
2835
{
2890
2836
  Table *table= item->table;
2891
 
  String tmp((char *)table->getUpdateRecord(), table->getShare()->getRecordLength(),
 
2837
  String tmp((char *)table->record[1], table->s->reclength,
2892
2838
             default_charset_info);
2893
2839
  String tmp2;
2894
2840
  String *result= &item->result;
2915
2861
        because it contains both order and arg list fields.
2916
2862
      */
2917
2863
      Field *field= (*arg)->get_tmp_table_field();
2918
 
      uint32_t offset= (field->offset(field->getTable()->record[0]) -
2919
 
                    table->getShare()->null_bytes);
2920
 
      assert(offset < table->getShare()->getRecordLength());
2921
 
      res= field->val_str_internal(&tmp, key + offset);
 
2864
      uint32_t offset= (field->offset(field->table->record[0]) -
 
2865
                    table->s->null_bytes);
 
2866
      assert(offset < table->s->reclength);
 
2867
      res= field->val_str(&tmp, key + offset);
2922
2868
    }
2923
2869
    else
2924
2870
      res= (*arg)->val_str(&tmp);
2966
2912
                       bool distinct_arg, List<Item> *select_list,
2967
2913
                       SQL_LIST *order_list, String *separator_arg)
2968
2914
  :tmp_table_param(0), warning(0),
2969
 
   separator(separator_arg), tree(NULL), unique_filter(NULL), table(0),
 
2915
   separator(separator_arg), tree(0), unique_filter(NULL), table(0),
2970
2916
   order(0), context(context_arg),
2971
2917
   arg_count_order(order_list ? order_list->elements : 0),
2972
2918
   arg_count_field(select_list->elements),
2987
2933
           (for possible order items in temporare tables)
2988
2934
    order - arg_count_order
2989
2935
  */
2990
 
  if (!(args= (Item**) memory::sql_alloc(sizeof(Item*) * arg_count +
2991
 
                                 sizeof(Order*)*arg_count_order)))
 
2936
  if (!(args= (Item**) sql_alloc(sizeof(Item*) * arg_count +
 
2937
                                 sizeof(order_st*)*arg_count_order)))
2992
2938
    return;
2993
2939
 
2994
 
  order= (Order**)(args + arg_count);
 
2940
  order= (order_st**)(args + arg_count);
2995
2941
 
2996
2942
  /* fill args items of show and sort */
2997
2943
  List_iterator_fast<Item> li(*select_list);
3001
2947
 
3002
2948
  if (arg_count_order)
3003
2949
  {
3004
 
    Order **order_ptr= order;
3005
 
    for (Order *order_item= (Order*) order_list->first;
 
2950
    order_st **order_ptr= order;
 
2951
    for (order_st *order_item= (order_st*) order_list->first;
3006
2952
         order_item != NULL;
3007
2953
         order_item= order_item->next)
3008
2954
    {
3014
2960
}
3015
2961
 
3016
2962
 
3017
 
Item_func_group_concat::Item_func_group_concat(Session *session,
 
2963
Item_func_group_concat::Item_func_group_concat(THD *thd,
3018
2964
                                               Item_func_group_concat *item)
3019
 
  :Item_sum(session, item),
 
2965
  :Item_sum(thd, item),
3020
2966
  tmp_table_param(item->tmp_table_param),
3021
2967
  warning(item->warning),
3022
2968
  separator(item->separator),
3048
2994
  if (warning)
3049
2995
  {
3050
2996
    char warn_buff[DRIZZLE_ERRMSG_SIZE];
3051
 
    snprintf(warn_buff, sizeof(warn_buff), ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
3052
 
    warning->set_msg(current_session, warn_buff);
 
2997
    sprintf(warn_buff, ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
 
2998
    warning->set_msg(current_thd, warn_buff);
3053
2999
    warning= 0;
3054
3000
  }
3055
3001
 
3063
3009
    tmp_table_param= 0;
3064
3010
    if (table)
3065
3011
    {
3066
 
      Session *session= table->in_use;
 
3012
      THD *thd= table->in_use;
 
3013
      table->free_tmp_table(thd);
3067
3014
      table= 0;
3068
3015
      if (tree)
3069
3016
      {
3078
3025
      if (warning)
3079
3026
      {
3080
3027
        char warn_buff[DRIZZLE_ERRMSG_SIZE];
3081
 
        snprintf(warn_buff, sizeof(warn_buff), ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
3082
 
        warning->set_msg(session, warn_buff);
 
3028
        sprintf(warn_buff, ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
 
3029
        warning->set_msg(thd, warn_buff);
3083
3030
        warning= 0;
3084
3031
      }
3085
3032
    }
3089
3036
}
3090
3037
 
3091
3038
 
3092
 
Item *Item_func_group_concat::copy_or_same(Session* session)
 
3039
Item *Item_func_group_concat::copy_or_same(THD* thd)
3093
3040
{
3094
 
  return new (session->mem_root) Item_func_group_concat(session, this);
 
3041
  return new (thd->mem_root) Item_func_group_concat(thd, this);
3095
3042
}
3096
3043
 
3097
3044
 
3115
3062
  if (always_null)
3116
3063
    return 0;
3117
3064
  copy_fields(tmp_table_param);
3118
 
  if (copy_funcs(tmp_table_param->items_to_copy, table->in_use))
3119
 
    return true;
 
3065
  copy_funcs(tmp_table_param->items_to_copy);
3120
3066
 
3121
3067
  for (uint32_t i= 0; i < arg_count_field; i++)
3122
3068
  {
3132
3078
  null_value= false;
3133
3079
  bool row_eligible= true;
3134
3080
 
3135
 
  if (distinct)
 
3081
  if (distinct) 
3136
3082
  {
3137
3083
    /* Filter out duplicate rows. */
3138
3084
    uint32_t count= unique_filter->elements_in_tree();
3139
 
    unique_filter->unique_add(table->record[0] + table->getShare()->null_bytes);
 
3085
    unique_filter->unique_add(table->record[0] + table->s->null_bytes);
3140
3086
    if (count == unique_filter->elements_in_tree())
3141
3087
      row_eligible= false;
3142
3088
  }
3143
3089
 
3144
3090
  TREE_ELEMENT *el= 0;                          // Only for safety
3145
3091
  if (row_eligible && tree)
3146
 
    el= tree_insert(tree, table->record[0] + table->getShare()->null_bytes, 0,
 
3092
    el= tree_insert(tree, table->record[0] + table->s->null_bytes, 0,
3147
3093
                    tree->custom_arg);
3148
3094
  /*
3149
3095
    If the row is not a duplicate (el->count == 1)
3152
3098
  */
3153
3099
  if (row_eligible && !warning_for_row &&
3154
3100
      (!tree || (el->count == 1 && distinct && !arg_count_order)))
3155
 
    dump_leaf_key(table->record[0] + table->getShare()->null_bytes, 1, this);
 
3101
    dump_leaf_key(table->record[0] + table->s->null_bytes, 1, this);
3156
3102
 
3157
3103
  return 0;
3158
3104
}
3159
3105
 
3160
3106
 
3161
3107
bool
3162
 
Item_func_group_concat::fix_fields(Session *session, Item **ref)
 
3108
Item_func_group_concat::fix_fields(THD *thd, Item **ref)
3163
3109
{
3164
3110
  uint32_t i;                       /* for loop variable */
3165
3111
  assert(fixed == 0);
3166
3112
 
3167
 
  if (init_sum_func_check(session))
 
3113
  if (init_sum_func_check(thd))
3168
3114
    return true;
3169
3115
 
3170
3116
  maybe_null= 1;
3176
3122
  for (i=0 ; i < arg_count ; i++)
3177
3123
  {
3178
3124
    if ((!args[i]->fixed &&
3179
 
         args[i]->fix_fields(session, args + i)) ||
 
3125
         args[i]->fix_fields(thd, args + i)) ||
3180
3126
        args[i]->check_cols(1))
3181
3127
      return true;
3182
3128
  }
3191
3137
  result.set_charset(collation.collation);
3192
3138
  result_field= 0;
3193
3139
  null_value= 1;
3194
 
  max_length= (size_t)session->variables.group_concat_max_len;
3195
 
 
3196
 
  if (check_sum_func(session, ref))
 
3140
  max_length= thd->variables.group_concat_max_len;
 
3141
 
 
3142
  uint32_t offset;
 
3143
  if (separator->needs_conversion(separator->length(), separator->charset(),
 
3144
                                  collation.collation, &offset))
 
3145
  {
 
3146
    uint32_t buflen= collation.collation->mbmaxlen * separator->length();
 
3147
    uint32_t errors, conv_length;
 
3148
    char *buf;
 
3149
    String *new_separator;
 
3150
 
 
3151
    if (!(buf= (char*) thd->alloc(buflen)) ||
 
3152
        !(new_separator= new(thd->mem_root)
 
3153
                           String(buf, buflen, collation.collation)))
 
3154
      return true;
 
3155
    
 
3156
    conv_length= copy_and_convert(buf, buflen, collation.collation,
 
3157
                                  separator->ptr(), separator->length(),
 
3158
                                  separator->charset(), &errors);
 
3159
    new_separator->length(conv_length);
 
3160
    separator= new_separator;
 
3161
  }
 
3162
 
 
3163
  if (check_sum_func(thd, ref))
3197
3164
    return true;
3198
3165
 
3199
3166
  fixed= 1;
3201
3168
}
3202
3169
 
3203
3170
 
3204
 
bool Item_func_group_concat::setup(Session *session)
 
3171
bool Item_func_group_concat::setup(THD *thd)
3205
3172
{
3206
3173
  List<Item> list;
3207
 
  Select_Lex *select_lex= session->lex->current_select;
 
3174
  SELECT_LEX *select_lex= thd->lex->current_select;
3208
3175
 
3209
3176
  /*
3210
3177
    Currently setup() can be called twice. Please add
3213
3180
  if (table || tree)
3214
3181
    return(false);
3215
3182
 
3216
 
  if (!(tmp_table_param= new Tmp_Table_Param))
 
3183
  if (!(tmp_table_param= new TMP_TABLE_PARAM))
3217
3184
    return(true);
3218
3185
 
3219
3186
  /* We'll convert all blobs to varchar fields in the temporary table */
3244
3211
    tmp table columns.
3245
3212
  */
3246
3213
  if (arg_count_order &&
3247
 
      setup_order(session, args, context->table_list, list, all_fields, *order))
 
3214
      setup_order(thd, args, context->table_list, list, all_fields, *order))
3248
3215
    return(true);
3249
3216
 
3250
3217
  count_field_types(select_lex, tmp_table_param, all_fields, 0);
3254
3221
  {
3255
3222
    /*
3256
3223
      Currently we have to force conversion of BLOB values to VARCHAR's
3257
 
      if we are to store them in TREE objects used for ORDER BY and
 
3224
      if we are to store them in TREE objects used for order_st BY and
3258
3225
      DISTINCT. This leads to truncation if the BLOB's size exceeds
3259
3226
      Field_varstring::MAX_SIZE.
3260
3227
    */
3261
 
    set_if_smaller(tmp_table_param->convert_blob_length,
 
3228
    set_if_smaller(tmp_table_param->convert_blob_length, 
3262
3229
                   Field_varstring::MAX_SIZE);
3263
3230
  }
3264
3231
 
3266
3233
    We have to create a temporary table to get descriptions of fields
3267
3234
    (types, sizes and so on).
3268
3235
 
3269
 
    Note that in the table, we first have the ORDER BY fields, then the
 
3236
    Note that in the table, we first have the order_st BY fields, then the
3270
3237
    field list.
3271
3238
  */
3272
 
  if (!(table= create_tmp_table(session, tmp_table_param, all_fields,
3273
 
                                (Order*) 0, 0, true,
3274
 
                                (select_lex->options | session->options),
 
3239
  if (!(table= create_tmp_table(thd, tmp_table_param, all_fields,
 
3240
                                (order_st*) 0, 0, true,
 
3241
                                (select_lex->options | thd->options),
3275
3242
                                HA_POS_ERROR, (char*) "")))
3276
 
  {
3277
3243
    return(true);
3278
 
  }
3279
 
 
3280
 
  table->cursor->extra(HA_EXTRA_NO_ROWS);
 
3244
  table->file->extra(HA_EXTRA_NO_ROWS);
3281
3245
  table->no_rows= 1;
3282
3246
 
3283
3247
  /*
3285
3249
     Don't reserve space for NULLs: if any of gconcat arguments is NULL,
3286
3250
     the row is not added to the result.
3287
3251
  */
3288
 
  uint32_t tree_key_length= table->getShare()->getRecordLength() - table->getShare()->null_bytes;
 
3252
  uint32_t tree_key_length= table->s->reclength - table->s->null_bytes;
3289
3253
 
3290
3254
  if (arg_count_order)
3291
3255
  {
3292
3256
    tree= &tree_base;
3293
3257
    /*
3294
3258
      Create a tree for sorting. The tree is used to sort (according to the
3295
 
      syntax of this function). If there is no ORDER BY clause, we don't
 
3259
      syntax of this function). If there is no order_st BY clause, we don't
3296
3260
      create this tree.
3297
3261
    */
3298
 
    init_tree(tree, (uint32_t) min(session->variables.max_heap_table_size,
3299
 
                                   (uint64_t)(session->variables.sortbuff_size/16)), 
3300
 
              0,
3301
 
              tree_key_length,
3302
 
              group_concat_key_cmp_with_order , false, NULL, (void*) this);
 
3262
    init_tree(tree, (uint) cmin(thd->variables.max_heap_table_size,
 
3263
                               thd->variables.sortbuff_size/16), 0,
 
3264
              tree_key_length, 
 
3265
              group_concat_key_cmp_with_order , 0, NULL, (void*) this);
3303
3266
  }
3304
3267
 
3305
3268
  if (distinct)
3306
3269
    unique_filter= new Unique(group_concat_key_cmp_with_distinct,
3307
3270
                              (void*)this,
3308
3271
                              tree_key_length,
3309
 
                              (size_t)session->variables.max_heap_table_size);
3310
 
 
 
3272
                              thd->variables.max_heap_table_size);
 
3273
  
3311
3274
  return(false);
3312
3275
}
3313
3276
 
3323
3286
  tree= 0;
3324
3287
}
3325
3288
 
3326
 
double Item_func_group_concat::val_real()
3327
 
{
3328
 
  String *res;  res=val_str(&str_value);
3329
 
  return res ? internal::my_atof(res->c_ptr()) : 0.0;
3330
 
}
3331
 
 
3332
 
int64_t Item_func_group_concat::val_int()
3333
 
{
3334
 
  String *res;
3335
 
  char *end_ptr;
3336
 
  int error;
3337
 
  if (!(res= val_str(&str_value)))
3338
 
    return (int64_t) 0;
3339
 
  end_ptr= (char*) res->ptr()+ res->length();
3340
 
  return internal::my_strtoll10(res->ptr(), &end_ptr, &error);
3341
 
}
3342
 
 
3343
 
String* Item_func_group_concat::val_str(String* )
 
3289
 
 
3290
String* Item_func_group_concat::val_str(String* str __attribute__((unused)))
3344
3291
{
3345
3292
  assert(fixed == 1);
3346
3293
  if (null_value)
3398
3345
Item_func_group_concat::~Item_func_group_concat()
3399
3346
{
3400
3347
  if (!original && unique_filter)
3401
 
    delete unique_filter;
 
3348
    delete unique_filter;    
3402
3349
}
3403
 
 
3404
 
} /* namespace drizzled */