← 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-20 04:28:21 UTC
  • mto: (492.3.21 drizzle-clean-code)
  • mto: This revision was merged to the branch mainline in revision 530.
  • Revision ID: brian@tangent.org-20081020042821-rqqdrccuu8195k3y
Second pass of thd cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item_sum.cc
33
33
    If the set function is not allowed in any subquery where it occurs
34
34
    an error is reported immediately.
35
35
 
36
 
  @param thd      reference to the thread context info
 
36
  @param session      reference to the thread context info
37
37
 
38
38
  @note
39
39
    This function is to be called for any item created for a set function
46
46
    FALSE  otherwise
47
47
*/
48
48
 
49
 
bool Item_sum::init_sum_func_check(Session *thd)
 
49
bool Item_sum::init_sum_func_check(Session *session)
50
50
{
51
 
  if (!thd->lex->allow_sum_func)
 
51
  if (!session->lex->allow_sum_func)
52
52
  {
53
53
    my_message(ER_INVALID_GROUP_FUNC_USE, ER(ER_INVALID_GROUP_FUNC_USE),
54
54
               MYF(0));
55
55
    return true;
56
56
  }
57
57
  /* Set a reference to the nesting set function if there is  any */
58
 
  in_sum_func= thd->lex->in_sum_func;
 
58
  in_sum_func= session->lex->in_sum_func;
59
59
  /* Save a pointer to object to be used in items for nested set functions */
60
 
  thd->lex->in_sum_func= this;
61
 
  nest_level= thd->lex->current_select->nest_level;
 
60
  session->lex->in_sum_func= this;
 
61
  nest_level= session->lex->current_select->nest_level;
62
62
  ref_by= 0;
63
63
  aggr_level= -1;
64
64
  aggr_sel= NULL;
86
86
    conditions. They are specified in the comment before the Item_sum
87
87
    class declaration.
88
88
    Additionally a bitmap variable called allow_sum_func is employed.
89
 
    It is included into the thd->lex structure.
 
89
    It is included into the session->lex structure.
90
90
    The bitmap contains 1 at n-th position if the set function happens
91
91
    to occur under a construct of the n-th level subquery where usage
92
92
    of set functions are allowed (i.e either in the SELECT list or
102
102
    - for AVG(t1.b) - 1 at the first position, 0 at the second position
103
103
    - for MIN(t2.d) - 1 at the first position, 1 at the second position.
104
104
 
105
 
  @param thd  reference to the thread context info
 
105
  @param session  reference to the thread context info
106
106
  @param ref  location of the pointer to this item in the embedding expression
107
107
 
108
108
  @note
117
117
    FALSE  otherwise
118
118
*/
119
119
 
120
 
bool Item_sum::check_sum_func(Session *thd, Item **ref)
 
120
bool Item_sum::check_sum_func(Session *session, Item **ref)
121
121
{
122
122
  bool invalid= false;
123
 
  nesting_map allow_sum_func= thd->lex->allow_sum_func;
 
123
  nesting_map allow_sum_func= session->lex->allow_sum_func;
124
124
  /*  
125
125
    The value of max_arg_level is updated if an argument of the set function
126
126
    contains a column reference resolved  against a subquery whose level is
144
144
      Try to find a subquery where it can be aggregated;
145
145
      If we fail to find such a subquery report an error.
146
146
    */
147
 
    if (register_sum_func(thd, ref))
 
147
    if (register_sum_func(session, ref))
148
148
      return true;
149
149
    invalid= aggr_level < 0 && !(allow_sum_func & (1 << nest_level));
150
150
    if (!invalid && false)
153
153
  if (!invalid && aggr_level < 0)
154
154
  {
155
155
    aggr_level= nest_level;
156
 
    aggr_sel= thd->lex->current_select;
 
156
    aggr_sel= session->lex->current_select;
157
157
  }
158
158
  /*
159
159
    By this moment we either found a subquery where the set function is
257
257
  }
258
258
  aggr_sel->full_group_by_flag|= SUM_FUNC_USED;
259
259
  update_used_tables();
260
 
  thd->lex->in_sum_func= in_sum_func;
 
260
  session->lex->in_sum_func= in_sum_func;
261
261
  return false;
262
262
}
263
263
 
277
277
    a subquery in one chain. It would simplify the process of 'splitting'
278
278
    for set functions.
279
279
 
280
 
  @param thd  reference to the thread context info
 
280
  @param session  reference to the thread context info
281
281
  @param ref  location of the pointer to this item in the embedding expression
282
282
 
283
283
  @retval
286
286
    TRUE   otherwise
287
287
*/  
288
288
 
289
 
bool Item_sum::register_sum_func(Session *thd, Item **ref)
 
289
bool Item_sum::register_sum_func(Session *session, Item **ref)
290
290
{
291
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() ;
 
292
  nesting_map allow_sum_func= session->lex->allow_sum_func;
 
293
  for (sl= session->lex->current_select->master_unit()->outer_select() ;
294
294
       sl && sl->nest_level > max_arg_level;
295
295
       sl= sl->master_unit()->outer_select() )
296
296
  {
341
341
      with_sum_func being set for an st_select_lex means that this st_select_lex
342
342
      has aggregate functions directly referenced (i.e. not through a sub-select).
343
343
    */
344
 
    for (sl= thd->lex->current_select; 
 
344
    for (sl= session->lex->current_select; 
345
345
         sl && sl != aggr_sel && sl->master_unit()->item;
346
346
         sl= sl->master_unit()->outer_select() )
347
347
      sl->master_unit()->item->with_sum_func= 1;
348
348
  }
349
 
  thd->lex->current_select->mark_as_dependent(aggr_sel);
 
349
  session->lex->current_select->mark_as_dependent(aggr_sel);
350
350
  return false;
351
351
}
352
352
 
374
374
  Constructor used in processing select with temporary tebles.
375
375
*/
376
376
 
377
 
Item_sum::Item_sum(Session *thd, Item_sum *item):
378
 
  Item_result_field(thd, item), arg_count(item->arg_count),
 
377
Item_sum::Item_sum(Session *session, Item_sum *item):
 
378
  Item_result_field(session, item), arg_count(item->arg_count),
379
379
  aggr_sel(item->aggr_sel),
380
380
  nest_level(item->nest_level), aggr_level(item->aggr_level),
381
381
  quick_group(item->quick_group), used_tables_cache(item->used_tables_cache),
384
384
  if (arg_count <= 2)
385
385
    args=tmp_args;
386
386
  else
387
 
    if (!(args= (Item**) thd->alloc(sizeof(Item*)*arg_count)))
 
387
    if (!(args= (Item**) session->alloc(sizeof(Item*)*arg_count)))
388
388
      return;
389
389
  memcpy(args, item->args, sizeof(Item*)*arg_count);
390
390
}
392
392
 
393
393
void Item_sum::mark_as_sum_func()
394
394
{
395
 
  SELECT_LEX *cur_select= current_thd->lex->current_select;
 
395
  SELECT_LEX *cur_select= current_session->lex->current_select;
396
396
  cur_select->n_sum_items++;
397
397
  cur_select->with_sum_func= 1;
398
398
  with_sum_func= 1;
439
439
  max_length=float_length(decimals);
440
440
}
441
441
 
442
 
Item *Item_sum::get_tmp_table_item(Session *thd)
 
442
Item *Item_sum::get_tmp_table_item(Session *session)
443
443
{
444
 
  Item_sum* sum_item= (Item_sum *) copy_or_same(thd);
 
444
  Item_sum* sum_item= (Item_sum *) copy_or_same(session);
445
445
  if (sum_item && sum_item->result_field)          // If not a const sum func
446
446
  {
447
447
    Field *result_field_tmp= sum_item->result_field;
559
559
 
560
560
 
561
561
bool
562
 
Item_sum_num::fix_fields(Session *thd, Item **ref)
 
562
Item_sum_num::fix_fields(Session *session, Item **ref)
563
563
{
564
564
  assert(fixed == 0);
565
565
 
566
 
  if (init_sum_func_check(thd))
 
566
  if (init_sum_func_check(session))
567
567
    return true;
568
568
 
569
569
  decimals=0;
570
570
  maybe_null=0;
571
571
  for (uint32_t i=0 ; i < arg_count ; i++)
572
572
  {
573
 
    if (args[i]->fix_fields(thd, args + i) || args[i]->check_cols(1))
 
573
    if (args[i]->fix_fields(session, args + i) || args[i]->check_cols(1))
574
574
      return true;
575
575
    set_if_bigger(decimals, args[i]->decimals);
576
576
    maybe_null |= args[i]->maybe_null;
580
580
  null_value=1;
581
581
  fix_length_and_dec();
582
582
 
583
 
  if (check_sum_func(thd, ref))
 
583
  if (check_sum_func(session, ref))
584
584
    return true;
585
585
 
586
586
  fixed= 1;
588
588
}
589
589
 
590
590
 
591
 
Item_sum_hybrid::Item_sum_hybrid(Session *thd, Item_sum_hybrid *item)
592
 
  :Item_sum(thd, item), value(item->value), hybrid_type(item->hybrid_type),
 
591
Item_sum_hybrid::Item_sum_hybrid(Session *session, Item_sum_hybrid *item)
 
592
  :Item_sum(session, item), value(item->value), hybrid_type(item->hybrid_type),
593
593
  hybrid_field_type(item->hybrid_field_type), cmp_sign(item->cmp_sign),
594
594
  was_values(item->was_values)
595
595
{
618
618
}
619
619
 
620
620
bool
621
 
Item_sum_hybrid::fix_fields(Session *thd, Item **ref)
 
621
Item_sum_hybrid::fix_fields(Session *session, Item **ref)
622
622
{
623
623
  assert(fixed == 0);
624
624
 
625
625
  Item *item= args[0];
626
626
 
627
 
  if (init_sum_func_check(thd))
 
627
  if (init_sum_func_check(session))
628
628
    return true;
629
629
 
630
630
  // 'item' can be changed during fix_fields
631
 
  if ((!item->fixed && item->fix_fields(thd, args)) ||
 
631
  if ((!item->fixed && item->fix_fields(session, args)) ||
632
632
      (item= args[0])->check_cols(1))
633
633
    return true;
634
634
  decimals=item->decimals;
666
666
  else
667
667
    hybrid_field_type= Item::field_type();
668
668
 
669
 
  if (check_sum_func(thd, ref))
 
669
  if (check_sum_func(session, ref))
670
670
    return true;
671
671
 
672
672
  fixed= 1;
681
681
  {
682
682
    field= ((Item_field*) args[0])->field;
683
683
    
684
 
    if ((field= create_tmp_field_from_field(current_thd, field, name, table,
 
684
    if ((field= create_tmp_field_from_field(current_session, field, name, table,
685
685
                                            NULL, convert_blob_length)))
686
686
      field->flags&= ~NOT_NULL_FLAG;
687
687
    return field;
719
719
  @todo
720
720
  check if the following assignments are really needed
721
721
*/
722
 
Item_sum_sum::Item_sum_sum(Session *thd, Item_sum_sum *item) 
723
 
  :Item_sum_num(thd, item), hybrid_type(item->hybrid_type),
 
722
Item_sum_sum::Item_sum_sum(Session *session, Item_sum_sum *item) 
 
723
  :Item_sum_num(session, item), hybrid_type(item->hybrid_type),
724
724
   curr_dec_buff(item->curr_dec_buff)
725
725
{
726
726
  /* TODO: check if the following assignments are really needed */
733
733
    sum= item->sum;
734
734
}
735
735
 
736
 
Item *Item_sum_sum::copy_or_same(Session* thd)
 
736
Item *Item_sum_sum::copy_or_same(Session* session)
737
737
{
738
 
  return new (thd->mem_root) Item_sum_sum(thd, this);
 
738
  return new (session->mem_root) Item_sum_sum(session, this);
739
739
}
740
740
 
741
741
 
884
884
}
885
885
 
886
886
 
887
 
Item_sum_distinct::Item_sum_distinct(Session *thd, Item_sum_distinct *original)
888
 
  :Item_sum_num(thd, original), val(original->val), tree(0),
 
887
Item_sum_distinct::Item_sum_distinct(Session *session, Item_sum_distinct *original)
 
888
  :Item_sum_num(session, original), val(original->val), tree(0),
889
889
  table_field_type(original->table_field_type)
890
890
{
891
891
  quick_group= 0;
970
970
  @todo
971
971
  check that the case of CHAR(0) works OK
972
972
*/
973
 
bool Item_sum_distinct::setup(Session *thd)
 
973
bool Item_sum_distinct::setup(Session *session)
974
974
{
975
975
  List<Create_field> field_list;
976
976
  Create_field field_def;                              /* field definition */
995
995
                               args[0]->decimals, args[0]->maybe_null,
996
996
                               args[0]->unsigned_flag);
997
997
 
998
 
  if (! (table= create_virtual_tmp_table(thd, field_list)))
 
998
  if (! (table= create_virtual_tmp_table(session, field_list)))
999
999
    return(true);
1000
1000
 
1001
1001
  /* XXX: check that the case of CHAR(0) works OK */
1008
1008
    are converted to binary representation as well.
1009
1009
  */
1010
1010
  tree= new Unique(simple_raw_key_cmp, &tree_key_length, tree_key_length,
1011
 
                   thd->variables.max_heap_table_size);
 
1011
                   session->variables.max_heap_table_size);
1012
1012
 
1013
1013
  is_evaluated= false;
1014
1014
  return(tree == 0);
1126
1126
Item_sum_avg_distinct::fix_length_and_dec()
1127
1127
{
1128
1128
  Item_sum_distinct::fix_length_and_dec();
1129
 
  prec_increment= current_thd->variables.div_precincrement;
 
1129
  prec_increment= current_session->variables.div_precincrement;
1130
1130
  /*
1131
1131
    AVG() will divide val by count. We need to reserve digits
1132
1132
    after decimal point as the result can be fractional.
1148
1148
}
1149
1149
 
1150
1150
 
1151
 
Item *Item_sum_count::copy_or_same(Session* thd)
 
1151
Item *Item_sum_count::copy_or_same(Session* session)
1152
1152
{
1153
 
  return new (thd->mem_root) Item_sum_count(thd, this);
 
1153
  return new (session->mem_root) Item_sum_count(session, this);
1154
1154
}
1155
1155
 
1156
1156
 
1189
1189
{
1190
1190
  Item_sum_sum::fix_length_and_dec();
1191
1191
  maybe_null=null_value=1;
1192
 
  prec_increment= current_thd->variables.div_precincrement;
 
1192
  prec_increment= current_session->variables.div_precincrement;
1193
1193
  if (hybrid_type == DECIMAL_RESULT)
1194
1194
  {
1195
1195
    int precision= args[0]->decimal_precision() + prec_increment;
1207
1207
}
1208
1208
 
1209
1209
 
1210
 
Item *Item_sum_avg::copy_or_same(Session* thd)
 
1210
Item *Item_sum_avg::copy_or_same(Session* session)
1211
1211
{
1212
 
  return new (thd->mem_root) Item_sum_avg(thd, this);
 
1212
  return new (session->mem_root) Item_sum_avg(session, this);
1213
1213
}
1214
1214
 
1215
1215
 
1312
1312
  return sqrt(nr);
1313
1313
}
1314
1314
 
1315
 
Item *Item_sum_std::copy_or_same(Session* thd)
 
1315
Item *Item_sum_std::copy_or_same(Session* session)
1316
1316
{
1317
 
  return new (thd->mem_root) Item_sum_std(thd, this);
 
1317
  return new (session->mem_root) Item_sum_std(session, this);
1318
1318
}
1319
1319
 
1320
1320
 
1366
1366
}
1367
1367
 
1368
1368
 
1369
 
Item_sum_variance::Item_sum_variance(Session *thd, Item_sum_variance *item):
1370
 
  Item_sum_num(thd, item), hybrid_type(item->hybrid_type),
 
1369
Item_sum_variance::Item_sum_variance(Session *session, Item_sum_variance *item):
 
1370
  Item_sum_num(session, item), hybrid_type(item->hybrid_type),
1371
1371
    count(item->count), sample(item->sample),
1372
1372
    prec_increment(item->prec_increment)
1373
1373
{
1379
1379
void Item_sum_variance::fix_length_and_dec()
1380
1380
{
1381
1381
  maybe_null= null_value= 1;
1382
 
  prec_increment= current_thd->variables.div_precincrement;
 
1382
  prec_increment= current_session->variables.div_precincrement;
1383
1383
 
1384
1384
  /*
1385
1385
    According to the SQL2003 standard (Part 2, Foundations; sec 10.9,
1412
1412
}
1413
1413
 
1414
1414
 
1415
 
Item *Item_sum_variance::copy_or_same(Session* thd)
 
1415
Item *Item_sum_variance::copy_or_same(Session* session)
1416
1416
{
1417
 
  return new (thd->mem_root) Item_sum_variance(thd, this);
 
1417
  return new (session->mem_root) Item_sum_variance(session, this);
1418
1418
}
1419
1419
 
1420
1420
 
1692
1692
}
1693
1693
 
1694
1694
 
1695
 
Item *Item_sum_min::copy_or_same(Session* thd)
 
1695
Item *Item_sum_min::copy_or_same(Session* session)
1696
1696
{
1697
 
  return new (thd->mem_root) Item_sum_min(thd, this);
 
1697
  return new (session->mem_root) Item_sum_min(session, this);
1698
1698
}
1699
1699
 
1700
1700
 
1756
1756
}
1757
1757
 
1758
1758
 
1759
 
Item *Item_sum_max::copy_or_same(Session* thd)
 
1759
Item *Item_sum_max::copy_or_same(Session* session)
1760
1760
{
1761
 
  return new (thd->mem_root) Item_sum_max(thd, this);
 
1761
  return new (session->mem_root) Item_sum_max(session, this);
1762
1762
}
1763
1763
 
1764
1764
 
1834
1834
  bits= reset_bits;
1835
1835
}
1836
1836
 
1837
 
Item *Item_sum_or::copy_or_same(Session* thd)
 
1837
Item *Item_sum_or::copy_or_same(Session* session)
1838
1838
{
1839
 
  return new (thd->mem_root) Item_sum_or(thd, this);
 
1839
  return new (session->mem_root) Item_sum_or(session, this);
1840
1840
}
1841
1841
 
1842
1842
 
1848
1848
  return 0;
1849
1849
}
1850
1850
 
1851
 
Item *Item_sum_xor::copy_or_same(Session* thd)
 
1851
Item *Item_sum_xor::copy_or_same(Session* session)
1852
1852
{
1853
 
  return new (thd->mem_root) Item_sum_xor(thd, this);
 
1853
  return new (session->mem_root) Item_sum_xor(session, this);
1854
1854
}
1855
1855
 
1856
1856
 
1862
1862
  return 0;
1863
1863
}
1864
1864
 
1865
 
Item *Item_sum_and::copy_or_same(Session* thd)
 
1865
Item *Item_sum_and::copy_or_same(Session* session)
1866
1866
{
1867
 
  return new (thd->mem_root) Item_sum_and(thd, this);
 
1867
  return new (session->mem_root) Item_sum_and(session, this);
1868
1868
}
1869
1869
 
1870
1870
 
2528
2528
}
2529
2529
 
2530
2530
 
2531
 
bool Item_sum_count_distinct::setup(Session *thd)
 
2531
bool Item_sum_count_distinct::setup(Session *session)
2532
2532
{
2533
2533
  List<Item> list;
2534
 
  SELECT_LEX *select_lex= thd->lex->current_select;
 
2534
  SELECT_LEX *select_lex= session->lex->current_select;
2535
2535
 
2536
2536
  /*
2537
2537
    Setup can be called twice for ROLLUP items. This is a bug.
2559
2559
  tmp_table_param->force_copy_fields= force_copy_fields;
2560
2560
  assert(table == 0);
2561
2561
 
2562
 
  if (!(table= create_tmp_table(thd, tmp_table_param, list, (order_st*) 0, 1,
 
2562
  if (!(table= create_tmp_table(session, tmp_table_param, list, (order_st*) 0, 1,
2563
2563
                                0,
2564
 
                                (select_lex->options | thd->options),
 
2564
                                (select_lex->options | session->options),
2565
2565
                                HA_POS_ERROR, (char*)"")))
2566
2566
    return true;
2567
2567
  table->file->extra(HA_EXTRA_NO_ROWS);         // Don't update rows
2614
2614
        uint32_t *length;
2615
2615
        compare_key= (qsort_cmp2) composite_key_cmp;
2616
2616
        cmp_arg= (void*) this;
2617
 
        field_lengths= (uint32_t*) thd->alloc(table->s->fields * sizeof(uint32_t));
 
2617
        field_lengths= (uint32_t*) session->alloc(table->s->fields * sizeof(uint32_t));
2618
2618
        for (tree_key_length= 0, length= field_lengths, field= table->field;
2619
2619
             field < field_end; ++field, ++length)
2620
2620
        {
2625
2625
    }
2626
2626
    assert(tree == 0);
2627
2627
    tree= new Unique(compare_key, cmp_arg, tree_key_length,
2628
 
                     thd->variables.max_heap_table_size);
 
2628
                     session->variables.max_heap_table_size);
2629
2629
    /*
2630
2630
      The only time tree_key_length could be 0 is if someone does
2631
2631
      count(distinct) on a char(0) field - stupid thing to do,
2640
2640
}
2641
2641
 
2642
2642
 
2643
 
Item *Item_sum_count_distinct::copy_or_same(Session* thd) 
 
2643
Item *Item_sum_count_distinct::copy_or_same(Session* session) 
2644
2644
{
2645
 
  return new (thd->mem_root) Item_sum_count_distinct(thd, this);
 
2645
  return new (session->mem_root) Item_sum_count_distinct(session, this);
2646
2646
}
2647
2647
 
2648
2648
 
2958
2958
}
2959
2959
 
2960
2960
 
2961
 
Item_func_group_concat::Item_func_group_concat(Session *thd,
 
2961
Item_func_group_concat::Item_func_group_concat(Session *session,
2962
2962
                                               Item_func_group_concat *item)
2963
 
  :Item_sum(thd, item),
 
2963
  :Item_sum(session, item),
2964
2964
  tmp_table_param(item->tmp_table_param),
2965
2965
  warning(item->warning),
2966
2966
  separator(item->separator),
2993
2993
  {
2994
2994
    char warn_buff[DRIZZLE_ERRMSG_SIZE];
2995
2995
    sprintf(warn_buff, ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
2996
 
    warning->set_msg(current_thd, warn_buff);
 
2996
    warning->set_msg(current_session, warn_buff);
2997
2997
    warning= 0;
2998
2998
  }
2999
2999
 
3007
3007
    tmp_table_param= 0;
3008
3008
    if (table)
3009
3009
    {
3010
 
      Session *thd= table->in_use;
3011
 
      table->free_tmp_table(thd);
 
3010
      Session *session= table->in_use;
 
3011
      table->free_tmp_table(session);
3012
3012
      table= 0;
3013
3013
      if (tree)
3014
3014
      {
3024
3024
      {
3025
3025
        char warn_buff[DRIZZLE_ERRMSG_SIZE];
3026
3026
        sprintf(warn_buff, ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
3027
 
        warning->set_msg(thd, warn_buff);
 
3027
        warning->set_msg(session, warn_buff);
3028
3028
        warning= 0;
3029
3029
      }
3030
3030
    }
3034
3034
}
3035
3035
 
3036
3036
 
3037
 
Item *Item_func_group_concat::copy_or_same(Session* thd)
 
3037
Item *Item_func_group_concat::copy_or_same(Session* session)
3038
3038
{
3039
 
  return new (thd->mem_root) Item_func_group_concat(thd, this);
 
3039
  return new (session->mem_root) Item_func_group_concat(session, this);
3040
3040
}
3041
3041
 
3042
3042
 
3103
3103
 
3104
3104
 
3105
3105
bool
3106
 
Item_func_group_concat::fix_fields(Session *thd, Item **ref)
 
3106
Item_func_group_concat::fix_fields(Session *session, Item **ref)
3107
3107
{
3108
3108
  uint32_t i;                       /* for loop variable */
3109
3109
  assert(fixed == 0);
3110
3110
 
3111
 
  if (init_sum_func_check(thd))
 
3111
  if (init_sum_func_check(session))
3112
3112
    return true;
3113
3113
 
3114
3114
  maybe_null= 1;
3120
3120
  for (i=0 ; i < arg_count ; i++)
3121
3121
  {
3122
3122
    if ((!args[i]->fixed &&
3123
 
         args[i]->fix_fields(thd, args + i)) ||
 
3123
         args[i]->fix_fields(session, args + i)) ||
3124
3124
        args[i]->check_cols(1))
3125
3125
      return true;
3126
3126
  }
3135
3135
  result.set_charset(collation.collation);
3136
3136
  result_field= 0;
3137
3137
  null_value= 1;
3138
 
  max_length= thd->variables.group_concat_max_len;
 
3138
  max_length= session->variables.group_concat_max_len;
3139
3139
 
3140
3140
  uint32_t offset;
3141
3141
  if (separator->needs_conversion(separator->length(), separator->charset(),
3146
3146
    char *buf;
3147
3147
    String *new_separator;
3148
3148
 
3149
 
    if (!(buf= (char*) thd->alloc(buflen)) ||
3150
 
        !(new_separator= new(thd->mem_root)
 
3149
    if (!(buf= (char*) session->alloc(buflen)) ||
 
3150
        !(new_separator= new(session->mem_root)
3151
3151
                           String(buf, buflen, collation.collation)))
3152
3152
      return true;
3153
3153
    
3158
3158
    separator= new_separator;
3159
3159
  }
3160
3160
 
3161
 
  if (check_sum_func(thd, ref))
 
3161
  if (check_sum_func(session, ref))
3162
3162
    return true;
3163
3163
 
3164
3164
  fixed= 1;
3166
3166
}
3167
3167
 
3168
3168
 
3169
 
bool Item_func_group_concat::setup(Session *thd)
 
3169
bool Item_func_group_concat::setup(Session *session)
3170
3170
{
3171
3171
  List<Item> list;
3172
 
  SELECT_LEX *select_lex= thd->lex->current_select;
 
3172
  SELECT_LEX *select_lex= session->lex->current_select;
3173
3173
 
3174
3174
  /*
3175
3175
    Currently setup() can be called twice. Please add
3209
3209
    tmp table columns.
3210
3210
  */
3211
3211
  if (arg_count_order &&
3212
 
      setup_order(thd, args, context->table_list, list, all_fields, *order))
 
3212
      setup_order(session, args, context->table_list, list, all_fields, *order))
3213
3213
    return(true);
3214
3214
 
3215
3215
  count_field_types(select_lex, tmp_table_param, all_fields, 0);
3234
3234
    Note that in the table, we first have the order_st BY fields, then the
3235
3235
    field list.
3236
3236
  */
3237
 
  if (!(table= create_tmp_table(thd, tmp_table_param, all_fields,
 
3237
  if (!(table= create_tmp_table(session, tmp_table_param, all_fields,
3238
3238
                                (order_st*) 0, 0, true,
3239
 
                                (select_lex->options | thd->options),
 
3239
                                (select_lex->options | session->options),
3240
3240
                                HA_POS_ERROR, (char*) "")))
3241
3241
    return(true);
3242
3242
  table->file->extra(HA_EXTRA_NO_ROWS);
3257
3257
      syntax of this function). If there is no order_st BY clause, we don't
3258
3258
      create this tree.
3259
3259
    */
3260
 
    init_tree(tree, (uint) cmin(thd->variables.max_heap_table_size,
3261
 
                               thd->variables.sortbuff_size/16), 0,
 
3260
    init_tree(tree, (uint) cmin(session->variables.max_heap_table_size,
 
3261
                               session->variables.sortbuff_size/16), 0,
3262
3262
              tree_key_length, 
3263
3263
              group_concat_key_cmp_with_order , 0, NULL, (void*) this);
3264
3264
  }
3267
3267
    unique_filter= new Unique(group_concat_key_cmp_with_distinct,
3268
3268
                              (void*)this,
3269
3269
                              tree_key_length,
3270
 
                              thd->variables.max_heap_table_size);
 
3270
                              session->variables.max_heap_table_size);
3271
3271
  
3272
3272
  return(false);
3273
3273
}