00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #pragma once
00021
00022
00023
00024 #include <drizzled/tree.h>
00025 #include <drizzled/hybrid_type.h>
00026 #include <drizzled/item.h>
00027 #include <drizzled/item/field.h>
00028 #include <drizzled/item/bin_string.h>
00029 #include <drizzled/charset_info.h>
00030
00031 namespace drizzled
00032 {
00033
00034 int group_concat_key_cmp_with_distinct(void* arg, const void* key1,
00035 const void* key2);
00036
00037 int group_concat_key_cmp_with_order(void* arg, const void* key1,
00038 const void* key2);
00039
00040 class Select_Lex;
00041 struct Order;
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238 class Item_sum :public Item_result_field
00239 {
00240 public:
00241 enum Sumfunctype
00242 { COUNT_FUNC, COUNT_DISTINCT_FUNC, SUM_FUNC, SUM_DISTINCT_FUNC, AVG_FUNC,
00243 AVG_DISTINCT_FUNC, MIN_FUNC, MAX_FUNC, STD_FUNC,
00244 VARIANCE_FUNC, SUM_BIT_FUNC, GROUP_CONCAT_FUNC
00245 };
00246
00247 Item **args, *tmp_args[2];
00248 Item **ref_by;
00249 Item_sum *next;
00250 uint32_t arg_count;
00251 Item_sum *in_sum_func;
00252 Select_Lex * aggr_sel;
00253 int8_t nest_level;
00254 int8_t aggr_level;
00255 int8_t max_arg_level;
00256 int8_t max_sum_func_level;
00257 bool quick_group;
00258
00259
00260
00261
00262
00263
00264 List<Item_field> outer_fields;
00265
00266 protected:
00267 table_map used_tables_cache;
00268 bool forced_const;
00269
00270 public:
00271
00272 void mark_as_sum_func();
00273 Item_sum() :arg_count(0), quick_group(1), forced_const(false)
00274 {
00275 mark_as_sum_func();
00276 }
00277 Item_sum(Item *a) :args(tmp_args), arg_count(1), quick_group(1),
00278 forced_const(false)
00279 {
00280 args[0]=a;
00281 mark_as_sum_func();
00282 }
00283 Item_sum( Item *a, Item *b ) :args(tmp_args), arg_count(2), quick_group(1),
00284 forced_const(false)
00285 {
00286 args[0]=a; args[1]=b;
00287 mark_as_sum_func();
00288 }
00289 Item_sum(List<Item> &list);
00290
00291 Item_sum(Session *session, Item_sum *item);
00292 enum Type type() const { return SUM_FUNC_ITEM; }
00293 virtual enum Sumfunctype sum_func () const=0;
00294
00295
00296
00297
00298
00299
00300 inline bool reset() { clear(); return add(); };
00301
00302
00303
00304
00305
00306
00307
00308 virtual void clear()= 0;
00309
00310
00311
00312
00313
00314
00315
00316 virtual bool add()=0;
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327 virtual void reset_field()=0;
00328
00329
00330
00331
00332
00333 virtual void update_field()=0;
00334 virtual bool keep_field_type(void) const { return 0; }
00335 virtual void fix_length_and_dec() { maybe_null=1; null_value=1; }
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351 virtual const char *func_name() const= 0;
00352 virtual Item *result_item(Field *field)
00353 { return new Item_field(field); }
00354 table_map used_tables() const { return used_tables_cache; }
00355 void update_used_tables ();
00356 void cleanup()
00357 {
00358 Item::cleanup();
00359 forced_const= false;
00360 }
00361 bool is_null() { return null_value; }
00362 void make_const ()
00363 {
00364 used_tables_cache= 0;
00365 forced_const= true;
00366 }
00367 virtual bool const_item() const { return forced_const; }
00368 virtual bool const_during_execution() const { return false; }
00369 void make_field(SendField *field);
00370 virtual void print(String *str);
00371 void fix_num_length_and_dec();
00372
00373
00374
00375
00376
00377
00378
00379
00380
00381 void no_rows_in_result() { clear(); }
00382
00383 virtual bool setup(Session *) {return 0;}
00384 virtual void make_unique(void) {}
00385 Item *get_tmp_table_item(Session *session);
00386 virtual Field *create_tmp_field(bool group, Table *table,
00387 uint32_t convert_blob_length);
00388 bool walk(Item_processor processor, bool walk_subquery, unsigned char *argument);
00389 bool init_sum_func_check(Session *session);
00390 bool check_sum_func(Session *session, Item **ref);
00391 bool register_sum_func(Session *session, Item **ref);
00392 Select_Lex *depended_from()
00393 { return (nest_level == aggr_level ? 0 : aggr_sel); }
00394 };
00395
00396
00397 class Item_sum_num :public Item_sum
00398 {
00399 protected:
00400
00401
00402
00403
00404
00405
00406 bool is_evaluated;
00407 public:
00408 Item_sum_num() :Item_sum(),is_evaluated(false) {}
00409 Item_sum_num(Item *item_par)
00410 :Item_sum(item_par), is_evaluated(false) {}
00411 Item_sum_num(Item *a, Item* b) :Item_sum(a,b),is_evaluated(false) {}
00412 Item_sum_num(List<Item> &list)
00413 :Item_sum(list), is_evaluated(false) {}
00414 Item_sum_num(Session *session, Item_sum_num *item)
00415 :Item_sum(session, item),is_evaluated(item->is_evaluated) {}
00416 bool fix_fields(Session *, Item **);
00417 int64_t val_int();
00418 String *val_str(String*str);
00419 type::Decimal *val_decimal(type::Decimal *);
00420 void reset_field();
00421 };
00422
00423
00424 class Item_sum_int :public Item_sum_num
00425 {
00426 public:
00427 Item_sum_int(Item *item_par) :Item_sum_num(item_par) {}
00428 Item_sum_int(List<Item> &list) :Item_sum_num(list) {}
00429 Item_sum_int(Session *session, Item_sum_int *item) :Item_sum_num(session, item) {}
00430 double val_real() { assert(fixed == 1); return (double) val_int(); }
00431 String *val_str(String*str);
00432 type::Decimal *val_decimal(type::Decimal *);
00433 enum Item_result result_type () const { return INT_RESULT; }
00434 void fix_length_and_dec()
00435 { decimals=0; max_length=21; maybe_null=null_value=0; }
00436 };
00437
00438
00439 class Item_sum_sum :public Item_sum_num
00440 {
00441 protected:
00442 Item_result hybrid_type;
00443 double sum;
00444 type::Decimal dec_buffs[2];
00445 uint32_t curr_dec_buff;
00446 void fix_length_and_dec();
00447
00448 public:
00449 Item_sum_sum(Item *item_par) :Item_sum_num(item_par) {}
00450 Item_sum_sum(Session *session, Item_sum_sum *item);
00451 enum Sumfunctype sum_func () const {return SUM_FUNC;}
00452 void clear();
00453 bool add();
00454 double val_real();
00455 int64_t val_int();
00456 String *val_str(String*str);
00457 type::Decimal *val_decimal(type::Decimal *);
00458 enum Item_result result_type () const { return hybrid_type; }
00459 void reset_field();
00460 void update_field();
00461 void no_rows_in_result() {}
00462 const char *func_name() const { return "sum("; }
00463 Item *copy_or_same(Session* session);
00464 };
00465
00466
00467
00468
00469
00470 class Unique;
00471
00472 class Item_sum_distinct :public Item_sum_num
00473 {
00474 protected:
00475
00476 uint64_t count;
00477 Hybrid_type val;
00478
00479 Unique *tree;
00480 Table *table;
00481 enum enum_field_types table_field_type;
00482 uint32_t tree_key_length;
00483 protected:
00484 Item_sum_distinct(Session *session, Item_sum_distinct *item);
00485 public:
00486 Item_sum_distinct(Item *item_par);
00487 ~Item_sum_distinct();
00488
00489 bool setup(Session *session);
00490 void clear();
00491 void cleanup();
00492 bool add();
00493 double val_real();
00494 type::Decimal *val_decimal(type::Decimal *);
00495 int64_t val_int();
00496 String *val_str(String *str);
00497
00498
00499
00500 enum Sumfunctype sum_func () const { return SUM_DISTINCT_FUNC; }
00501 void reset_field() {}
00502 void update_field() {}
00503 virtual void no_rows_in_result() {}
00504 void fix_length_and_dec();
00505 enum Item_result result_type () const;
00506 virtual void calculate_val_and_count();
00507 virtual bool unique_walk_function(void *elem);
00508 };
00509
00510
00511
00512
00513
00514
00515
00516
00517 class Item_sum_sum_distinct :public Item_sum_distinct
00518 {
00519 private:
00520 Item_sum_sum_distinct(Session *session, Item_sum_sum_distinct *item)
00521 :Item_sum_distinct(session, item) {}
00522 public:
00523 Item_sum_sum_distinct(Item *item_arg) :Item_sum_distinct(item_arg) {}
00524
00525 enum Sumfunctype sum_func () const { return SUM_DISTINCT_FUNC; }
00526 const char *func_name() const { return "sum(distinct "; }
00527 Item *copy_or_same(Session* session) { return new Item_sum_sum_distinct(session, this); }
00528 };
00529
00530
00531
00532
00533 class Item_sum_avg_distinct: public Item_sum_distinct
00534 {
00535 private:
00536 Item_sum_avg_distinct(Session *session, Item_sum_avg_distinct *original)
00537 :Item_sum_distinct(session, original) {}
00538 public:
00539 uint32_t prec_increment;
00540 Item_sum_avg_distinct(Item *item_arg) : Item_sum_distinct(item_arg) {}
00541
00542 void fix_length_and_dec();
00543 virtual void calculate_val_and_count();
00544 enum Sumfunctype sum_func () const { return AVG_DISTINCT_FUNC; }
00545 const char *func_name() const { return "avg(distinct "; }
00546 Item *copy_or_same(Session* session) { return new Item_sum_avg_distinct(session, this); }
00547 };
00548
00549
00550 class Item_sum_count :public Item_sum_int
00551 {
00552 int64_t count;
00553
00554 public:
00555 Item_sum_count(Item *item_par)
00556 :Item_sum_int(item_par),count(0)
00557 {}
00558 Item_sum_count(Session *session, Item_sum_count *item)
00559 :Item_sum_int(session, item), count(item->count)
00560 {}
00561 enum Sumfunctype sum_func () const { return COUNT_FUNC; }
00562 void clear();
00563 void no_rows_in_result() { count=0; }
00564 bool add();
00565 void make_const_count(int64_t count_arg)
00566 {
00567 count=count_arg;
00568 Item_sum::make_const();
00569 }
00570 int64_t val_int();
00571 void reset_field();
00572 void cleanup();
00573 void update_field();
00574 const char *func_name() const { return "count("; }
00575 Item *copy_or_same(Session* session);
00576 };
00577
00578
00579 class Tmp_Table_Param;
00580
00581 class Item_sum_count_distinct :public Item_sum_int
00582 {
00583 Table *table;
00584 uint32_t *field_lengths;
00585 Tmp_Table_Param *tmp_table_param;
00586 bool force_copy_fields;
00587
00588
00589
00590
00591
00592 Unique *tree;
00593
00594
00595
00596
00597
00598 int64_t count;
00599
00600
00601
00602
00603 Item_sum_count_distinct *original;
00604 uint32_t tree_key_length;
00605
00606
00607 bool always_null;
00608
00609
00610 friend int composite_key_cmp(void* arg, unsigned char* key1, unsigned char* key2);
00611 friend int simple_str_key_cmp(void* arg, unsigned char* key1, unsigned char* key2);
00612
00613 public:
00614 Item_sum_count_distinct(List<Item> &list)
00615 :Item_sum_int(list), table(0), field_lengths(0), tmp_table_param(0),
00616 force_copy_fields(0), tree(0), count(0),
00617 original(0), always_null(false)
00618 { quick_group= 0; }
00619 Item_sum_count_distinct(Session *session, Item_sum_count_distinct *item)
00620 :Item_sum_int(session, item), table(item->table),
00621 field_lengths(item->field_lengths),
00622 tmp_table_param(item->tmp_table_param),
00623 force_copy_fields(0), tree(item->tree), count(item->count),
00624 original(item), tree_key_length(item->tree_key_length),
00625 always_null(item->always_null)
00626 {}
00627 ~Item_sum_count_distinct();
00628
00629 void cleanup();
00630
00631 enum Sumfunctype sum_func () const { return COUNT_DISTINCT_FUNC; }
00632 void clear();
00633 bool add();
00634 int64_t val_int();
00635 void reset_field() { return ;}
00636 void update_field() { return ; }
00637 const char *func_name() const { return "count(distinct "; }
00638 bool setup(Session *session);
00639 void make_unique();
00640 Item *copy_or_same(Session* session);
00641 void no_rows_in_result() {}
00642 };
00643
00644
00645
00646
00647 class Item_sum_avg;
00648
00649 class Item_avg_field :public Item_result_field
00650 {
00651 public:
00652 Field *field;
00653 Item_result hybrid_type;
00654 uint32_t f_precision, f_scale, dec_bin_size;
00655 uint32_t prec_increment;
00656 Item_avg_field(Item_result res_type, Item_sum_avg *item);
00657 enum Type type() const { return FIELD_AVG_ITEM; }
00658 double val_real();
00659 int64_t val_int();
00660 type::Decimal *val_decimal(type::Decimal *);
00661 bool is_null() { update_null_value(); return null_value; }
00662 String *val_str(String*);
00663 enum_field_types field_type() const
00664 {
00665 return hybrid_type == DECIMAL_RESULT ?
00666 DRIZZLE_TYPE_DECIMAL : DRIZZLE_TYPE_DOUBLE;
00667 }
00668 void fix_length_and_dec() {}
00669 enum Item_result result_type () const { return hybrid_type; }
00670 };
00671
00672
00673 class Item_sum_avg :public Item_sum_sum
00674 {
00675 public:
00676 uint64_t count;
00677 uint32_t prec_increment;
00678 uint32_t f_precision, f_scale, dec_bin_size;
00679
00680 Item_sum_avg(Item *item_par) :Item_sum_sum(item_par), count(0) {}
00681 Item_sum_avg(Session *session, Item_sum_avg *item)
00682 :Item_sum_sum(session, item), count(item->count),
00683 prec_increment(item->prec_increment) {}
00684
00685 void fix_length_and_dec();
00686 enum Sumfunctype sum_func () const {return AVG_FUNC;}
00687 void clear();
00688 bool add();
00689 double val_real();
00690
00691 int64_t val_int();
00692 type::Decimal *val_decimal(type::Decimal *);
00693 String *val_str(String *str);
00694 void reset_field();
00695 void update_field();
00696 Item *result_item(Field *)
00697 { return new Item_avg_field(hybrid_type, this); }
00698 void no_rows_in_result() {}
00699 const char *func_name() const { return "avg("; }
00700 Item *copy_or_same(Session* session);
00701 Field *create_tmp_field(bool group, Table *table, uint32_t convert_blob_length);
00702 void cleanup()
00703 {
00704 count= 0;
00705 Item_sum_sum::cleanup();
00706 }
00707 };
00708
00709 class Item_sum_variance;
00710
00711 class Item_variance_field :public Item_result_field
00712 {
00713 public:
00714 Field *field;
00715 Item_result hybrid_type;
00716 uint32_t f_precision0, f_scale0;
00717 uint32_t f_precision1, f_scale1;
00718 uint32_t dec_bin_size0, dec_bin_size1;
00719 uint32_t sample;
00720 uint32_t prec_increment;
00721 Item_variance_field(Item_sum_variance *item);
00722 enum Type type() const {return FIELD_VARIANCE_ITEM; }
00723 double val_real();
00724 int64_t val_int();
00725 String *val_str(String *str)
00726 { return val_string_from_real(str); }
00727 type::Decimal *val_decimal(type::Decimal *dec_buf)
00728 { return val_decimal_from_real(dec_buf); }
00729 bool is_null() { update_null_value(); return null_value; }
00730 enum_field_types field_type() const
00731 {
00732 return hybrid_type == DECIMAL_RESULT ?
00733 DRIZZLE_TYPE_DECIMAL : DRIZZLE_TYPE_DOUBLE;
00734 }
00735 void fix_length_and_dec() {}
00736 enum Item_result result_type () const { return hybrid_type; }
00737 };
00738
00739
00740
00741
00742
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760 class Item_sum_variance : public Item_sum_num
00761 {
00762 void fix_length_and_dec();
00763
00764 public:
00765 Item_result hybrid_type;
00766 int cur_dec;
00767 double recurrence_m, recurrence_s;
00768 uint64_t count;
00769 uint32_t f_precision0, f_scale0;
00770 uint32_t f_precision1, f_scale1;
00771 uint32_t dec_bin_size0, dec_bin_size1;
00772 uint32_t sample;
00773 uint32_t prec_increment;
00774
00775 Item_sum_variance(Item *item_par, uint32_t sample_arg) :Item_sum_num(item_par),
00776 hybrid_type(REAL_RESULT), count(0), sample(sample_arg)
00777 {}
00778 Item_sum_variance(Session *session, Item_sum_variance *item);
00779 enum Sumfunctype sum_func () const { return VARIANCE_FUNC; }
00780 void clear();
00781 bool add();
00782 double val_real();
00783 int64_t val_int();
00784 type::Decimal *val_decimal(type::Decimal *);
00785 void reset_field();
00786 void update_field();
00787 Item *result_item(Field *)
00788 { return new Item_variance_field(this); }
00789 void no_rows_in_result() {}
00790 const char *func_name() const
00791 { return sample ? "var_samp(" : "variance("; }
00792 Item *copy_or_same(Session* session);
00793 Field *create_tmp_field(bool group, Table *table, uint32_t convert_blob_length);
00794 enum Item_result result_type () const { return REAL_RESULT; }
00795 void cleanup()
00796 {
00797 count= 0;
00798 Item_sum_num::cleanup();
00799 }
00800 };
00801
00802 class Item_sum_std;
00803
00804 class Item_std_field :public Item_variance_field
00805 {
00806 public:
00807 Item_std_field(Item_sum_std *item);
00808 enum Type type() const { return FIELD_STD_ITEM; }
00809 double val_real();
00810 type::Decimal *val_decimal(type::Decimal *);
00811 enum Item_result result_type () const { return REAL_RESULT; }
00812 enum_field_types field_type() const { return DRIZZLE_TYPE_DOUBLE;}
00813 };
00814
00815
00816
00817
00818
00819 class Item_sum_std :public Item_sum_variance
00820 {
00821 public:
00822 Item_sum_std(Item *item_par, uint32_t sample_arg)
00823 :Item_sum_variance(item_par, sample_arg) {}
00824 Item_sum_std(Session *session, Item_sum_std *item)
00825 :Item_sum_variance(session, item)
00826 {}
00827 enum Sumfunctype sum_func () const { return STD_FUNC; }
00828 double val_real();
00829 Item *result_item(Field *)
00830 { return new Item_std_field(this); }
00831 const char *func_name() const { return "std("; }
00832 Item *copy_or_same(Session* session);
00833 enum Item_result result_type () const { return REAL_RESULT; }
00834 enum_field_types field_type() const { return DRIZZLE_TYPE_DOUBLE;}
00835 };
00836
00837
00838
00839 class Item_sum_hybrid :public Item_sum
00840 {
00841 protected:
00842 String value,tmp_value;
00843 double sum;
00844 int64_t sum_int;
00845 type::Decimal sum_dec;
00846 Item_result hybrid_type;
00847 enum_field_types hybrid_field_type;
00848 int cmp_sign;
00849 bool was_values;
00850
00851 public:
00852 Item_sum_hybrid(Item *item_par,int sign)
00853 :Item_sum(item_par), sum(0.0), sum_int(0),
00854 hybrid_type(INT_RESULT), hybrid_field_type(DRIZZLE_TYPE_LONGLONG),
00855 cmp_sign(sign), was_values(true)
00856 { collation.set(&my_charset_bin); }
00857 Item_sum_hybrid(Session *session, Item_sum_hybrid *item);
00858 bool fix_fields(Session *, Item **);
00859 void clear();
00860 double val_real();
00861 int64_t val_int();
00862 type::Decimal *val_decimal(type::Decimal *);
00863 void reset_field();
00864 String *val_str(String *);
00865 bool keep_field_type(void) const { return 1; }
00866 enum Item_result result_type () const { return hybrid_type; }
00867 enum enum_field_types field_type() const { return hybrid_field_type; }
00868 void update_field();
00869 void min_max_update_str_field();
00870 void min_max_update_real_field();
00871 void min_max_update_int_field();
00872 void min_max_update_decimal_field();
00873 void cleanup();
00874 bool any_value() { return was_values; }
00875 void no_rows_in_result();
00876 Field *create_tmp_field(bool group, Table *table,
00877 uint32_t convert_blob_length);
00878 };
00879
00880
00881 class Item_sum_min :public Item_sum_hybrid
00882 {
00883 public:
00884 Item_sum_min(Item *item_par) :Item_sum_hybrid(item_par,1) {}
00885 Item_sum_min(Session *session, Item_sum_min *item) :Item_sum_hybrid(session, item) {}
00886 enum Sumfunctype sum_func () const {return MIN_FUNC;}
00887
00888 bool add();
00889 const char *func_name() const { return "min("; }
00890 Item *copy_or_same(Session* session);
00891 };
00892
00893
00894 class Item_sum_max :public Item_sum_hybrid
00895 {
00896 public:
00897 Item_sum_max(Item *item_par) :Item_sum_hybrid(item_par,-1) {}
00898 Item_sum_max(Session *session, Item_sum_max *item) :Item_sum_hybrid(session, item) {}
00899 enum Sumfunctype sum_func () const {return MAX_FUNC;}
00900
00901 bool add();
00902 const char *func_name() const { return "max("; }
00903 Item *copy_or_same(Session* session);
00904 };
00905
00906
00907 class Item_sum_bit :public Item_sum_int
00908 {
00909 protected:
00910 uint64_t reset_bits,bits;
00911
00912 public:
00913 Item_sum_bit(Item *item_par,uint64_t reset_arg)
00914 :Item_sum_int(item_par),reset_bits(reset_arg),bits(reset_arg) {}
00915 Item_sum_bit(Session *session, Item_sum_bit *item):
00916 Item_sum_int(session, item), reset_bits(item->reset_bits), bits(item->bits) {}
00917 enum Sumfunctype sum_func () const {return SUM_BIT_FUNC;}
00918 void clear();
00919 int64_t val_int();
00920 void reset_field();
00921 void update_field();
00922 void fix_length_and_dec()
00923 { decimals= 0; max_length=21; unsigned_flag= 1; maybe_null= null_value= 0; }
00924 void cleanup()
00925 {
00926 bits= reset_bits;
00927 Item_sum_int::cleanup();
00928 }
00929 };
00930
00931
00932 class Item_sum_or :public Item_sum_bit
00933 {
00934 public:
00935 Item_sum_or(Item *item_par) :Item_sum_bit(item_par,0) {}
00936 Item_sum_or(Session *session, Item_sum_or *item) :Item_sum_bit(session, item) {}
00937 bool add();
00938 const char *func_name() const { return "bit_or("; }
00939 Item *copy_or_same(Session* session);
00940 };
00941
00942
00943 class Item_sum_and :public Item_sum_bit
00944 {
00945 public:
00946 Item_sum_and(Item *item_par) :Item_sum_bit(item_par, UINT64_MAX) {}
00947 Item_sum_and(Session *session, Item_sum_and *item) :Item_sum_bit(session, item) {}
00948 bool add();
00949 const char *func_name() const { return "bit_and("; }
00950 Item *copy_or_same(Session* session);
00951 };
00952
00953 class Item_sum_xor :public Item_sum_bit
00954 {
00955 public:
00956 Item_sum_xor(Item *item_par) :Item_sum_bit(item_par,0) {}
00957 Item_sum_xor(Session *session, Item_sum_xor *item) :Item_sum_bit(session, item) {}
00958 bool add();
00959 const char *func_name() const { return "bit_xor("; }
00960 Item *copy_or_same(Session* session);
00961 };
00962
00963
00964
00965 class DRIZZLE_ERROR;
00966
00967 class Item_func_group_concat : public Item_sum
00968 {
00969 Tmp_Table_Param *tmp_table_param;
00970 DRIZZLE_ERROR *warning;
00971 String result;
00972 String *separator;
00973 TREE tree_base;
00974 TREE *tree;
00975
00983 Unique *unique_filter;
00984 Table *table;
00985 Order **order;
00986 Name_resolution_context *context;
00988 uint32_t arg_count_order;
00990 uint32_t arg_count_field;
00991 uint32_t count_cut_values;
00992 bool distinct;
00993 bool warning_for_row;
00994 bool always_null;
00995 bool force_copy_fields;
00996 bool no_appended;
00997
00998
00999
01000
01001 Item_func_group_concat *original;
01002
01003 friend int group_concat_key_cmp_with_distinct(void* arg, const void* key1,
01004 const void* key2);
01005 friend int group_concat_key_cmp_with_order(void* arg, const void* key1,
01006 const void* key2);
01007 friend int dump_leaf_key(unsigned char* key, uint32_t,
01008 Item_func_group_concat *group_concat_item);
01009
01010 public:
01011 Item_func_group_concat(Name_resolution_context *context_arg,
01012 bool is_distinct, List<Item> *is_select,
01013 SQL_LIST *is_order, String *is_separator);
01014
01015 Item_func_group_concat(Session *session, Item_func_group_concat *item);
01016 ~Item_func_group_concat();
01017 void cleanup();
01018
01019 enum Sumfunctype sum_func () const {return GROUP_CONCAT_FUNC;}
01020 const char *func_name() const { return "group_concat"; }
01021 virtual Item_result result_type () const { return STRING_RESULT; }
01022 enum_field_types field_type() const
01023 {
01024 if (max_length/collation.collation->mbmaxlen > CONVERT_IF_BIGGER_TO_BLOB )
01025 return DRIZZLE_TYPE_BLOB;
01026 else
01027 return DRIZZLE_TYPE_VARCHAR;
01028 }
01029 void clear();
01030 bool add();
01031 void reset_field() { assert(0); }
01032 void update_field() { assert(0); }
01033 bool fix_fields(Session *,Item **);
01034 bool setup(Session *session);
01035 void make_unique();
01036 double val_real();
01037 int64_t val_int();
01038 type::Decimal *val_decimal(type::Decimal *decimal_value)
01039 {
01040 return val_decimal_from_string(decimal_value);
01041 }
01042 String* val_str(String* str);
01043 Item *copy_or_same(Session* session);
01044 void no_rows_in_result() {}
01045 virtual void print(String *str);
01046 virtual bool change_context_processor(unsigned char *cntx)
01047 { context= (Name_resolution_context *)cntx; return false; }
01048 };
01049
01050 }
01051