← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/sum.cc

  • Committer: Stewart Smith
  • Date: 2009-08-20 17:15:54 UTC
  • mto: (1119.2.2 merge)
  • mto: This revision was merged to the branch mainline in revision 1124.
  • Revision ID: stewart@flamingspork.com-20090820171554-72eo1tqlc4n64rak
Valgrind 3.5 requires --alignment to be a power of 2 between 16 and 4096. The specifying --alignment is not important for us, so remove it.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/sum.cc
20
20
  @brief
21
21
  Sum functions (COUNT, MIN...)
22
22
*/
23
 
#include "config.h"
24
 
#include <math.h>
 
23
#include <drizzled/server_includes.h>
25
24
#include <drizzled/sql_select.h>
26
25
#include <drizzled/error.h>
27
26
#include <drizzled/hybrid_type_traits.h>
36
35
#include <drizzled/field/date.h>
37
36
#include <drizzled/field/datetime.h>
38
37
 
39
 
#include "drizzled/internal/m_string.h"
40
 
 
41
38
#include <algorithm>
42
39
 
43
40
using namespace std;
44
41
 
45
 
namespace drizzled
46
 
{
47
 
 
48
42
extern my_decimal decimal_zero;
49
 
extern plugin::StorageEngine *heap_engine;
50
43
 
51
44
/**
52
45
  Prepare an aggregate function item for checking context conditions.
380
373
Item_sum::Item_sum(List<Item> &list) :arg_count(list.elements),
381
374
  forced_const(false)
382
375
{
383
 
  if ((args=(Item**) memory::sql_alloc(sizeof(Item*)*arg_count)))
 
376
  if ((args=(Item**) sql_alloc(sizeof(Item*)*arg_count)))
384
377
  {
385
378
    uint32_t i=0;
386
379
    List_iterator_fast<Item> li(list);
524
517
                               name, table->s, collation.collation);
525
518
    break;
526
519
  case DECIMAL_RESULT:
527
 
    field= new Field_decimal(max_length, maybe_null, name,
 
520
    field= new Field_new_decimal(max_length, maybe_null, name,
528
521
                                 decimals, unsigned_flag);
529
522
    break;
530
523
  case ROW_RESULT:
876
869
 
877
870
/***************************************************************************/
878
871
 
 
872
#ifdef __cplusplus
 
873
extern "C" {
 
874
#endif
 
875
 
879
876
/* Declarations for auxilary C-callbacks */
880
877
 
881
878
static int simple_raw_key_cmp(void* arg, const void* key1, const void* key2)
885
882
 
886
883
 
887
884
static int item_sum_distinct_walk(void *element,
888
 
                                  uint32_t ,
 
885
                                  element_count ,
889
886
                                  void *item)
890
887
{
891
888
  return ((Item_sum_distinct*) (item))->unique_walk_function(element);
892
889
}
893
890
 
 
891
#ifdef __cplusplus
 
892
}
 
893
#endif
 
894
 
894
895
/* Item_sum_distinct */
895
896
 
896
897
Item_sum_distinct::Item_sum_distinct(Item *item_arg)
979
980
  case DECIMAL_RESULT:
980
981
    val.traits= Hybrid_type_traits_decimal::instance();
981
982
    if (table_field_type != DRIZZLE_TYPE_LONGLONG)
982
 
      table_field_type= DRIZZLE_TYPE_DECIMAL;
 
983
      table_field_type= DRIZZLE_TYPE_NEWDECIMAL;
983
984
    break;
984
985
  case ROW_RESULT:
985
986
  default:
1021
1022
  assert(args[0]->fixed);
1022
1023
 
1023
1024
  field_def.init_for_tmp_table(table_field_type, args[0]->max_length,
1024
 
                               args[0]->decimals, args[0]->maybe_null);
 
1025
                               args[0]->decimals, args[0]->maybe_null,
 
1026
                               args[0]->unsigned_flag);
1025
1027
 
1026
1028
  if (! (table= create_virtual_tmp_table(session, field_list)))
1027
1029
    return(true);
1258
1260
                               0, name, table->s, &my_charset_bin);
1259
1261
  }
1260
1262
  else if (hybrid_type == DECIMAL_RESULT)
1261
 
    field= new Field_decimal(max_length, maybe_null, name,
1262
 
                             decimals, unsigned_flag);
 
1263
    field= new Field_new_decimal(max_length, maybe_null, name,
 
1264
                                 decimals, unsigned_flag);
1263
1265
  else
1264
1266
    field= new Field_double(max_length, maybe_null, name, decimals, true);
1265
1267
  if (field)
2508
2510
  return 0;
2509
2511
}
2510
2512
 
 
2513
#ifdef __cplusplus
 
2514
extern "C" {
 
2515
#endif
 
2516
 
2511
2517
static int count_distinct_walk(void *,
2512
 
                               uint32_t ,
 
2518
                               element_count ,
2513
2519
                               void *arg)
2514
2520
{
2515
2521
  (*((uint64_t*)arg))++;
2516
2522
  return 0;
2517
2523
}
2518
2524
 
 
2525
#ifdef __cplusplus
 
2526
}
 
2527
#endif
 
2528
 
 
2529
 
 
2530
 
2519
2531
void Item_sum_count_distinct::cleanup()
2520
2532
{
2521
2533
  Item_sum_int::cleanup();
2603
2615
                                (select_lex->options | session->options),
2604
2616
                                HA_POS_ERROR, (char*)"")))
2605
2617
    return true;
2606
 
  table->cursor->extra(HA_EXTRA_NO_ROWS);               // Don't update rows
 
2618
  table->file->extra(HA_EXTRA_NO_ROWS);         // Don't update rows
2607
2619
  table->no_rows=1;
2608
2620
 
2609
2621
  if (table->s->db_type() == heap_engine)
2695
2707
  }
2696
2708
  else if (table)
2697
2709
  {
2698
 
    table->cursor->extra(HA_EXTRA_NO_CACHE);
2699
 
    table->cursor->ha_delete_all_rows();
2700
 
    table->cursor->extra(HA_EXTRA_WRITE_CACHE);
 
2710
    table->file->extra(HA_EXTRA_NO_CACHE);
 
2711
    table->file->ha_delete_all_rows();
 
2712
    table->file->extra(HA_EXTRA_WRITE_CACHE);
2701
2713
  }
2702
2714
}
2703
2715
 
2724
2736
    */
2725
2737
    return tree->unique_add(table->record[0] + table->s->null_bytes);
2726
2738
  }
2727
 
  if ((error= table->cursor->ha_write_row(table->record[0])) &&
2728
 
      table->cursor->is_fatal_error(error, HA_CHECK_DUP))
 
2739
  if ((error= table->file->ha_write_row(table->record[0])) &&
 
2740
      table->file->is_fatal_error(error, HA_CHECK_DUP))
2729
2741
    return true;
2730
2742
  return false;
2731
2743
}
2750
2762
    return (int64_t) count;
2751
2763
  }
2752
2764
 
2753
 
  error= table->cursor->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
 
2765
  error= table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
2754
2766
 
2755
2767
  if(error)
2756
2768
  {
2757
 
    table->print_error(error, MYF(0));
 
2769
    table->file->print_error(error, MYF(0));
2758
2770
  }
2759
2771
 
2760
 
  return table->cursor->stats.records;
 
2772
  return table->file->stats.records;
2761
2773
}
2762
2774
 
2763
2775
/*****************************************************************************
2820
2832
 
2821
2833
 
2822
2834
/**
2823
 
  function of sort for syntax: GROUP_CONCAT(expr,... ORDER BY col,... )
 
2835
  function of sort for syntax: GROUP_CONCAT(expr,... order_st BY col,... )
2824
2836
*/
2825
2837
 
2826
2838
int group_concat_key_cmp_with_order(void* arg, const void* key1,
2867
2879
  Append data from current leaf to item->result.
2868
2880
*/
2869
2881
 
2870
 
int dump_leaf_key(unsigned char* key, uint32_t ,
 
2882
int dump_leaf_key(unsigned char* key, element_count ,
2871
2883
                  Item_func_group_concat *item)
2872
2884
{
2873
2885
  Table *table= item->table;
2949
2961
                       bool distinct_arg, List<Item> *select_list,
2950
2962
                       SQL_LIST *order_list, String *separator_arg)
2951
2963
  :tmp_table_param(0), warning(0),
2952
 
   separator(separator_arg), tree(NULL), unique_filter(NULL), table(0),
 
2964
   separator(separator_arg), tree(0), unique_filter(NULL), table(0),
2953
2965
   order(0), context(context_arg),
2954
2966
   arg_count_order(order_list ? order_list->elements : 0),
2955
2967
   arg_count_field(select_list->elements),
2970
2982
           (for possible order items in temporare tables)
2971
2983
    order - arg_count_order
2972
2984
  */
2973
 
  if (!(args= (Item**) memory::sql_alloc(sizeof(Item*) * arg_count +
 
2985
  if (!(args= (Item**) sql_alloc(sizeof(Item*) * arg_count +
2974
2986
                                 sizeof(order_st*)*arg_count_order)))
2975
2987
    return;
2976
2988
 
3031
3043
  if (warning)
3032
3044
  {
3033
3045
    char warn_buff[DRIZZLE_ERRMSG_SIZE];
3034
 
    snprintf(warn_buff, sizeof(warn_buff), ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
 
3046
    sprintf(warn_buff, ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
3035
3047
    warning->set_msg(current_session, warn_buff);
3036
3048
    warning= 0;
3037
3049
  }
3062
3074
      if (warning)
3063
3075
      {
3064
3076
        char warn_buff[DRIZZLE_ERRMSG_SIZE];
3065
 
        snprintf(warn_buff, sizeof(warn_buff), ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
 
3077
        sprintf(warn_buff, ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
3066
3078
        warning->set_msg(session, warn_buff);
3067
3079
        warning= 0;
3068
3080
      }
3237
3249
  {
3238
3250
    /*
3239
3251
      Currently we have to force conversion of BLOB values to VARCHAR's
3240
 
      if we are to store them in TREE objects used for ORDER BY and
 
3252
      if we are to store them in TREE objects used for order_st BY and
3241
3253
      DISTINCT. This leads to truncation if the BLOB's size exceeds
3242
3254
      Field_varstring::MAX_SIZE.
3243
3255
    */
3249
3261
    We have to create a temporary table to get descriptions of fields
3250
3262
    (types, sizes and so on).
3251
3263
 
3252
 
    Note that in the table, we first have the ORDER BY fields, then the
 
3264
    Note that in the table, we first have the order_st BY fields, then the
3253
3265
    field list.
3254
3266
  */
3255
3267
  if (!(table= create_tmp_table(session, tmp_table_param, all_fields,
3257
3269
                                (select_lex->options | session->options),
3258
3270
                                HA_POS_ERROR, (char*) "")))
3259
3271
    return(true);
3260
 
  table->cursor->extra(HA_EXTRA_NO_ROWS);
 
3272
  table->file->extra(HA_EXTRA_NO_ROWS);
3261
3273
  table->no_rows= 1;
3262
3274
 
3263
3275
  /*
3272
3284
    tree= &tree_base;
3273
3285
    /*
3274
3286
      Create a tree for sorting. The tree is used to sort (according to the
3275
 
      syntax of this function). If there is no ORDER BY clause, we don't
 
3287
      syntax of this function). If there is no order_st BY clause, we don't
3276
3288
      create this tree.
3277
3289
    */
3278
3290
    init_tree(tree, (uint32_t) min(session->variables.max_heap_table_size,
3279
 
                                   (uint64_t)(session->variables.sortbuff_size/16)), 
3280
 
              0,
 
3291
                                   (uint64_t)(session->variables.sortbuff_size/16)), 0,
3281
3292
              tree_key_length,
3282
 
              group_concat_key_cmp_with_order , false, NULL, (void*) this);
 
3293
              group_concat_key_cmp_with_order , 0, NULL, (void*) this);
3283
3294
  }
3284
3295
 
3285
3296
  if (distinct)
3303
3314
  tree= 0;
3304
3315
}
3305
3316
 
3306
 
double Item_func_group_concat::val_real()
3307
 
{
3308
 
  String *res;  res=val_str(&str_value);
3309
 
  return res ? internal::my_atof(res->c_ptr()) : 0.0;
3310
 
}
3311
 
 
3312
 
int64_t Item_func_group_concat::val_int()
3313
 
{
3314
 
  String *res;
3315
 
  char *end_ptr;
3316
 
  int error;
3317
 
  if (!(res= val_str(&str_value)))
3318
 
    return (int64_t) 0;
3319
 
  end_ptr= (char*) res->ptr()+ res->length();
3320
 
  return internal::my_strtoll10(res->ptr(), &end_ptr, &error);
3321
 
}
3322
3317
 
3323
3318
String* Item_func_group_concat::val_str(String* )
3324
3319
{
3380
3375
  if (!original && unique_filter)
3381
3376
    delete unique_filter;
3382
3377
}
3383
 
 
3384
 
} /* namespace drizzled */