← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/cmpfunc.h

  • Committer: Brian Aker
  • Date: 2009-12-06 01:55:53 UTC
  • mfrom: (1238.1.5 push)
  • Revision ID: brian@gaz-20091206015553-cva833q4gvwj11ob
Bundle for staging.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/cmpfunc.h
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
22
22
 
23
23
/* compare and test functions */
24
24
 
25
 
#include <drizzled/common.h>
26
 
#include <drizzled/comp_creator.h>
27
 
#include <drizzled/function/math/int.h>
28
 
#include <drizzled/function/numhybrid.h>
29
 
#include <drizzled/item/decimal.h>
30
 
#include <drizzled/item/float.h>
31
 
#include <drizzled/item/function/boolean.h>
32
 
#include <drizzled/item/int.h>
33
 
#include <drizzled/item/row.h>
34
 
#include <drizzled/item/string.h>
35
 
#include <drizzled/item/sum.h>
36
 
#include <drizzled/qsort_cmp.h>
37
 
 
38
 
namespace drizzled
39
 
{
 
25
#include "drizzled/comp_creator.h"
 
26
#include "drizzled/item/row.h"
 
27
#include "drizzled/item/sum.h"
 
28
#include "drizzled/item/int.h"
 
29
#include "drizzled/item/float.h"
 
30
#include "drizzled/item/decimal.h"
 
31
#include "drizzled/function/math/int.h"
 
32
#include "drizzled/function/numhybrid.h"
 
33
#include "drizzled/session.h"
 
34
#include "drizzled/common.h"
40
35
 
41
36
extern Item_result item_cmp_type(Item_result a,Item_result b);
42
 
 
43
37
class Item_bool_func2;
44
38
class Arg_comparator;
45
39
class Item_sum_hybrid;
46
40
class Item_row;
47
 
class Session;
48
41
 
49
42
typedef int (Arg_comparator::*arg_cmp_func)();
50
43
 
51
44
typedef int (*Item_field_cmpfunc)(Item_field *f1, Item_field *f2, void *arg);
52
45
 
53
 
int64_t get_datetime_value(Session *session, 
54
 
                           Item ***item_arg, 
55
 
                           Item **cache_arg,
56
 
                           Item *warn_item, 
57
 
                           bool *is_null);
 
46
uint64_t get_datetime_value(Session *session, 
 
47
                            Item ***item_arg, 
 
48
                            Item **cache_arg,
 
49
                            Item *warn_item, 
 
50
                            bool *is_null);
58
51
 
59
 
class Arg_comparator: public memory::SqlAlloc
 
52
class Arg_comparator: public Sql_alloc
60
53
{
61
54
  Item **a, **b;
62
55
  arg_cmp_func func;
70
63
  bool is_nulls_eq;                // TRUE <=> compare for the EQUAL_FUNC
71
64
  enum enum_date_cmp_type { CMP_DATE_DFLT= 0, CMP_DATE_WITH_DATE,
72
65
                            CMP_DATE_WITH_STR, CMP_STR_WITH_DATE };
73
 
  int64_t (*get_value_func)(Session *session, Item ***item_arg, Item **cache_arg,
74
 
                            Item *warn_item, bool *is_null);
 
66
  uint64_t (*get_value_func)(Session *session, Item ***item_arg, Item **cache_arg,
 
67
                              Item *warn_item, bool *is_null);
75
68
public:
76
69
  DTCollation cmp_collation;
77
70
 
78
 
  Arg_comparator();
79
 
 
80
 
  Arg_comparator(Item **a1, Item **a2);
 
71
  Arg_comparator(): session(0), a_cache(0), b_cache(0) {};
 
72
  Arg_comparator(Item **a1, Item **a2): a(a1), b(a2), session(0),
 
73
    a_cache(0), b_cache(0) {};
81
74
 
82
75
  int set_compare_func(Item_bool_func2 *owner, Item_result type);
83
76
  inline int set_compare_func(Item_bool_func2 *owner_arg)
119
112
  int compare_datetime();        // compare args[0] & args[1] as DATETIMEs
120
113
 
121
114
  static enum enum_date_cmp_type can_compare_as_dates(Item *a, Item *b,
122
 
                                                      int64_t *const_val_arg);
 
115
                                                      uint64_t *const_val_arg);
123
116
 
124
117
  void set_datetime_cmp_func(Item **a1, Item **b1);
125
118
  static arg_cmp_func comparator_matrix [5][2];
127
120
  friend class Item_func;
128
121
};
129
122
 
 
123
class Item_bool_func :public Item_int_func
 
124
{
 
125
public:
 
126
  Item_bool_func() :Item_int_func() {}
 
127
  Item_bool_func(Item *a) :Item_int_func(a) {}
 
128
  Item_bool_func(Item *a,Item *b) :Item_int_func(a,b) {}
 
129
  Item_bool_func(Session *session, Item_bool_func *item) :Item_int_func(session, item) {}
 
130
  bool is_bool_func() { return 1; }
 
131
  void fix_length_and_dec() { decimals=0; max_length=1; }
 
132
  uint32_t decimal_precision() const { return 1; }
 
133
};
 
134
 
130
135
 
131
136
/**
132
137
  Abstract Item class, to represent <code>X IS [NOT] (TRUE | FALSE)</code>
133
138
  boolean predicates.
134
139
*/
135
140
 
136
 
class Item_func_truth : public item::function::Boolean
 
141
class Item_func_truth : public Item_bool_func
137
142
{
138
143
public:
139
144
  virtual bool val_bool();
143
148
 
144
149
protected:
145
150
  Item_func_truth(Item *a, bool a_value, bool a_affirmative)
146
 
  : item::function::Boolean(a), value(a_value), affirmative(a_affirmative)
 
151
  : Item_bool_func(a), value(a_value), affirmative(a_affirmative)
147
152
  {}
148
153
 
149
154
  ~Item_func_truth()
232
237
    placed into a separate class called 'Item_in_optimizer'.
233
238
*/
234
239
 
235
 
class Item_in_optimizer: public item::function::Boolean
 
240
class Item_in_optimizer: public Item_bool_func
236
241
{
237
242
protected:
238
243
  Item_cache *cache;
246
251
  bool result_for_null_param;
247
252
public:
248
253
  Item_in_optimizer(Item *a, Item_in_subselect *b):
249
 
    item::function::Boolean(a, reinterpret_cast<Item *>(b)), cache(0),
 
254
    Item_bool_func(a, reinterpret_cast<Item *>(b)), cache(0),
250
255
    save_cache(0), result_for_null_param(UNKNOWN)
251
256
  { with_subselect= true; }
252
257
  bool fix_fields(Session *, Item **);
378
383
  { return true; }
379
384
};
380
385
 
381
 
class Item_func_not :public item::function::Boolean
 
386
class Item_func_not :public Item_bool_func
382
387
{
383
388
public:
384
 
  Item_func_not(Item *a) :item::function::Boolean(a) {}
 
389
  Item_func_not(Item *a) :Item_bool_func(a) {}
385
390
  int64_t val_int();
386
391
  enum Functype functype() const { return NOT_FUNC; }
387
392
  const char *func_name() const { return "not"; }
420
425
   - To wrap condition that is pushed down into subquery
421
426
*/
422
427
 
423
 
class Item_func_trig_cond: public item::function::Boolean
 
428
class Item_func_trig_cond: public Item_bool_func
424
429
{
425
430
  bool *trig_var;
426
431
public:
427
 
  Item_func_trig_cond(Item *a, bool *f) : item::function::Boolean(a) { trig_var= f; }
 
432
  Item_func_trig_cond(Item *a, bool *f) : Item_bool_func(a) { trig_var= f; }
428
433
  int64_t val_int() { return *trig_var ? args[0]->val_int() : 1; }
429
434
  enum Functype functype() const { return TRIG_COND_FUNC; };
430
435
  const char *func_name() const { return "trigcond"; };
641
646
{
642
647
  Item_result type;
643
648
  double dbl;
644
 
  type::Decimal dec;
 
649
  my_decimal dec;
645
650
};
646
651
 
647
652
class Item_func_interval :public Item_int_func
672
677
  double real_op();
673
678
  int64_t int_op();
674
679
  String *str_op(String *);
675
 
  type::Decimal *decimal_op(type::Decimal *);
 
680
  my_decimal *decimal_op(my_decimal *);
676
681
  void fix_length_and_dec();
677
682
  void find_num_type() {}
678
683
  enum Item_result result_type () const { return hybrid_type; }
691
696
  double real_op();
692
697
  int64_t int_op();
693
698
  String *str_op(String *str);
694
 
  type::Decimal *decimal_op(type::Decimal *);
 
699
  my_decimal *decimal_op(my_decimal *);
695
700
  enum_field_types field_type() const;
696
701
  void fix_length_and_dec();
697
702
  const char *func_name() const { return "ifnull"; }
715
720
  double val_real();
716
721
  int64_t val_int();
717
722
  String *val_str(String *str);
718
 
  type::Decimal *val_decimal(type::Decimal *);
 
723
  my_decimal *val_decimal(my_decimal *);
719
724
  enum Item_result result_type () const { return cached_result_type; }
720
725
  enum_field_types field_type() const { return cached_field_type; }
721
726
  bool fix_fields(Session *, Item **);
735
740
  double val_real();
736
741
  int64_t val_int();
737
742
  String *val_str(String *str);
738
 
  type::Decimal *val_decimal(type::Decimal *);
 
743
  my_decimal *val_decimal(my_decimal *);
739
744
  enum Item_result result_type () const { return cached_result_type; }
740
745
  void fix_length_and_dec();
741
746
  uint32_t decimal_precision() const { return args[0]->decimal_precision(); }
756
761
 
757
762
/* A vector of values of some type  */
758
763
 
759
 
class in_vector :public memory::SqlAlloc
 
764
class in_vector :public Sql_alloc
760
765
{
761
766
public:
762
767
  char *base;
768
773
  in_vector() {}
769
774
  in_vector(uint32_t elements,uint32_t element_length,qsort2_cmp cmp_func,
770
775
            const CHARSET_INFO * const cmp_coll)
771
 
    :base((char*) memory::sql_calloc(elements*element_length)),
 
776
    :base((char*) sql_calloc(elements*element_length)),
772
777
     size(element_length), compare(cmp_func), collation(cmp_coll),
773
778
     count(elements), used_count(elements) {}
774
779
  virtual ~in_vector() {}
775
780
  virtual void set(uint32_t pos,Item *item)=0;
776
781
  virtual unsigned char *get_value(Item *item)=0;
777
 
  void sort();
 
782
  void sort()
 
783
  {
 
784
    my_qsort2(base,used_count,size,compare, (void *) collation);
 
785
  }
778
786
  int find(Item *item);
779
787
 
780
788
  /*
880
888
  /* Cache for the left item. */
881
889
  Item *lval_cache;
882
890
 
883
 
  in_datetime(Item *warn_item_arg, uint32_t elements);
884
 
 
 
891
  in_datetime(Item *warn_item_arg, uint32_t elements)
 
892
    :in_int64_t(elements), session(current_session), warn_item(warn_item_arg),
 
893
     lval_cache(0) {};
885
894
  void set(uint32_t pos,Item *item);
886
895
  unsigned char *get_value(Item *item);
887
896
  friend int cmp_int64_t(void *cmp_arg, packed_int64_t *a,packed_int64_t *b);
909
918
 
910
919
class in_decimal :public in_vector
911
920
{
912
 
  type::Decimal val;
 
921
  my_decimal val;
913
922
public:
914
923
  in_decimal(uint32_t elements);
915
924
  void set(uint32_t pos, Item *item);
920
929
  }
921
930
  void value_to_item(uint32_t pos, Item *item)
922
931
  {
923
 
    type::Decimal *dec= ((type::Decimal *)base) + pos;
 
932
    my_decimal *dec= ((my_decimal *)base) + pos;
924
933
    Item_decimal *item_dec= (Item_decimal*)item;
925
934
    item_dec->set_decimal_value(dec);
926
935
  }
933
942
** Classes for easy comparing of non const items
934
943
*/
935
944
 
936
 
class cmp_item :public memory::SqlAlloc
 
945
class cmp_item :public Sql_alloc
937
946
{
938
947
public:
939
948
  const CHARSET_INFO *cmp_charset;
940
 
 
941
 
  cmp_item()
942
 
  {
943
 
    cmp_charset= &my_charset_bin;
944
 
  }
945
 
 
 
949
  cmp_item() { cmp_charset= &my_charset_bin; }
946
950
  virtual ~cmp_item() {}
947
951
  virtual void store_value(Item *item)= 0;
948
952
  virtual int cmp(Item *item)= 0;
1033
1037
*/
1034
1038
class cmp_item_datetime :public cmp_item
1035
1039
{
1036
 
  int64_t value;
1037
 
 
 
1040
  uint64_t value;
1038
1041
public:
1039
1042
  Session *session;
1040
1043
  /* Item used for issuing warnings. */
1042
1045
  /* Cache for the left item. */
1043
1046
  Item *lval_cache;
1044
1047
 
1045
 
  cmp_item_datetime(Item *warn_item_arg);
1046
 
 
 
1048
  cmp_item_datetime(Item *warn_item_arg)
 
1049
    :session(current_session), warn_item(warn_item_arg), lval_cache(0) {}
1047
1050
  void store_value(Item *item);
1048
1051
  int cmp(Item *arg);
1049
1052
  int compare(cmp_item *ci);
1074
1077
 
1075
1078
class cmp_item_decimal :public cmp_item
1076
1079
{
1077
 
  type::Decimal value;
 
1080
  my_decimal value;
1078
1081
public:
1079
1082
  cmp_item_decimal() {}                       /* Remove gcc warning */
1080
1083
  void store_value(Item *item);
1145
1148
  Item_result cmp_type;
1146
1149
  DTCollation cmp_collation;
1147
1150
  enum_field_types cached_field_type;
1148
 
  cmp_item *cmp_items[DECIMAL_RESULT+1]; /* For all result types */
 
1151
  cmp_item *cmp_items[5]; /* For all result types */
1149
1152
  cmp_item *case_item;
1150
1153
public:
1151
1154
  Item_func_case(List<Item> &list, Item *first_expr_arg, Item *else_expr_arg)
1169
1172
  double val_real();
1170
1173
  int64_t val_int();
1171
1174
  String *val_str(String *);
1172
 
  type::Decimal *val_decimal(type::Decimal *);
 
1175
  my_decimal *val_decimal(my_decimal *);
1173
1176
  bool fix_fields(Session *session, Item **ref);
1174
1177
  void fix_length_and_dec();
1175
1178
  uint32_t decimal_precision() const;
1230
1233
  uint32_t decimal_precision() const { return 1; }
1231
1234
  void cleanup()
1232
1235
  {
 
1236
    uint32_t i;
1233
1237
    Item_int_func::cleanup();
1234
1238
    delete array;
1235
1239
    array= 0;
1236
 
    for (int i= STRING_RESULT; i <= DECIMAL_RESULT; i++)
 
1240
    for (i= 0; i <= (uint32_t)DECIMAL_RESULT + 1; i++)
1237
1241
    {
1238
1242
      delete cmp_items[i];
1239
1243
      cmp_items[i]= 0;
1281
1285
 
1282
1286
/* Functions used by where clause */
1283
1287
 
1284
 
class Item_func_isnull :public item::function::Boolean
 
1288
class Item_func_isnull :public Item_bool_func
1285
1289
{
1286
1290
protected:
1287
1291
  int64_t cached_value;
1288
1292
public:
1289
 
  Item_func_isnull(Item *a) :item::function::Boolean(a) {}
 
1293
  Item_func_isnull(Item *a) :Item_bool_func(a) {}
1290
1294
  int64_t val_int();
1291
1295
  enum Functype functype() const { return ISNULL_FUNC; }
1292
1296
  void fix_length_and_dec()
1348
1352
};
1349
1353
 
1350
1354
 
1351
 
class Item_func_isnotnull :public item::function::Boolean
 
1355
class Item_func_isnotnull :public Item_bool_func
1352
1356
{
1353
1357
  bool abort_on_null;
1354
1358
public:
1355
 
  Item_func_isnotnull(Item *a) :item::function::Boolean(a), abort_on_null(0) {}
 
1359
  Item_func_isnotnull(Item *a) :Item_bool_func(a), abort_on_null(0) {}
1356
1360
  int64_t val_int();
1357
1361
  enum Functype functype() const { return ISNOTNULL_FUNC; }
1358
1362
  void fix_length_and_dec()
1412
1416
 
1413
1417
typedef class Item COND;
1414
1418
 
1415
 
class Item_cond :public item::function::Boolean
 
1419
class Item_cond :public Item_bool_func
1416
1420
{
1417
1421
protected:
1418
1422
  List<Item> list;
1424
1428
  using Item::split_sum_func;
1425
1429
 
1426
1430
  /* Item_cond() is only used to create top level items */
1427
 
  Item_cond(): item::function::Boolean(), abort_on_null(1)
 
1431
  Item_cond(): Item_bool_func(), abort_on_null(1)
1428
1432
  { const_item_cache=0; }
1429
1433
  Item_cond(Item *i1,Item *i2)
1430
 
    :item::function::Boolean(), abort_on_null(0)
 
1434
    :Item_bool_func(), abort_on_null(0)
1431
1435
  {
1432
1436
    list.push_back(i1);
1433
1437
    list.push_back(i2);
1434
1438
  }
1435
1439
  Item_cond(Session *session, Item_cond *item);
1436
1440
  Item_cond(List<Item> &nlist)
1437
 
    :item::function::Boolean(), list(nlist), abort_on_null(0) {}
 
1441
    :Item_bool_func(), list(nlist), abort_on_null(0) {}
1438
1442
  bool add(Item *item) { return list.push_back(item); }
1439
1443
  bool add_at_head(Item *item) { return list.push_front(item); }
1440
1444
  void add_at_head(List<Item> *nlist) { list.prepand(nlist); }
1538
1542
  object represents f1=f2= ...=fn to the projection of known fields fi1=...=fik.
1539
1543
*/
1540
1544
 
1541
 
class Item_equal: public item::function::Boolean
 
1545
class Item_equal: public Item_bool_func
1542
1546
{
 
1547
  List<Item_field> fields; /* list of equal field items                    */
 
1548
  Item *const_item;        /* optional constant item equal to fields items */
 
1549
  cmp_item *eval_item;
 
1550
  bool cond_false;
1543
1551
public:
1544
 
  typedef List<Item_field> fields_t;
1545
 
 
1546
 
  Item_equal() :
1547
 
    const_item(0),
1548
 
    eval_item(0),
1549
 
    cond_false(0)
1550
 
  {
1551
 
    const_item_cache=0;
1552
 
  }
1553
 
 
1554
 
  fields_t::iterator begin()
1555
 
  {
1556
 
    return fields.begin();
1557
 
  }
1558
 
 
 
1552
  inline Item_equal()
 
1553
    : Item_bool_func(), const_item(0), eval_item(0), cond_false(0)
 
1554
  { const_item_cache=0 ;}
1559
1555
  Item_equal(Item_field *f1, Item_field *f2);
1560
1556
  Item_equal(Item *c, Item_field *f);
1561
1557
  Item_equal(Item_equal *item_equal);
1581
1577
  virtual void print(String *str, enum_query_type query_type);
1582
1578
  const CHARSET_INFO *compare_collation()
1583
1579
  { return fields.head()->collation.collation; }
1584
 
private:
1585
 
  fields_t fields; /* list of equal field items                    */
1586
 
  Item *const_item;        /* optional constant item equal to fields items */
1587
 
  cmp_item *eval_item;
1588
 
  bool cond_false;
1589
 
 
1590
1580
};
1591
1581
 
1592
 
class COND_EQUAL: public memory::SqlAlloc
 
1582
class COND_EQUAL: public Sql_alloc
1593
1583
{
1594
1584
public:
1595
1585
  uint32_t max_members;               /* max number of members the current level
1604
1594
};
1605
1595
 
1606
1596
 
1607
 
class Item_equal_iterator : public List<Item_field>::iterator
 
1597
class Item_equal_iterator : public List_iterator_fast<Item_field>
1608
1598
{
1609
1599
public:
1610
1600
  inline Item_equal_iterator(Item_equal &item_equal)
1611
 
    :List<Item_field>::iterator (item_equal.fields.begin() )
 
1601
    :List_iterator_fast<Item_field> (item_equal.fields)
1612
1602
  {}
1613
1603
  inline Item_field* operator++(int)
1614
1604
  {
1615
 
    Item_field *item= (*(List<Item_field>::iterator *) this)++;
 
1605
    Item_field *item= (*(List_iterator_fast<Item_field> *) this)++;
1616
1606
    return  item;
1617
1607
  }
 
1608
  inline void rewind(void)
 
1609
  {
 
1610
    List_iterator_fast<Item_field>::rewind();
 
1611
  }
1618
1612
};
1619
1613
 
1620
1614
class Item_cond_and :public Item_cond
1713
1707
 
1714
1708
Item *and_expressions(Item *a, Item *b, Item **org_item);
1715
1709
 
1716
 
} /* namespace drizzled */
1717
 
 
1718
1710
#endif /* DRIZZLED_ITEM_CMPFUNC_H */