← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/cmpfunc.h

  • Committer: Eric Herman
  • Date: 2008-12-06 19:42:46 UTC
  • mto: (656.1.6 devel)
  • mto: This revision was merged to the branch mainline in revision 665.
  • Revision ID: eric@mysql.com-20081206194246-5cdexuu81i366eek
removed trailing whitespace with simple script:

for file in $(find . -name "*.c") $(find . -name "*.cc") $(find . -name "*.h"); do ruby -pe 'gsub(/\s+$/, $/)' < $file > $file.out; mv $file.out $file; done;

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/cmpfunc.h
37
37
 
38
38
typedef int (Arg_comparator::*arg_cmp_func)();
39
39
 
40
 
typedef int (*Item_field_cmpfunc)(Item_field *f1, Item_field *f2, void *arg); 
 
40
typedef int (*Item_field_cmpfunc)(Item_field *f1, Item_field *f2, void *arg);
41
41
 
42
42
class Arg_comparator: public Sql_alloc
43
43
{
232
232
protected:
233
233
  Item_cache *cache;
234
234
  bool save_cache;
235
 
  /* 
 
235
  /*
236
236
    Stores the value of "NULL IN (SELECT ...)" for uncorrelated subqueries:
237
237
      UNKNOWN - "NULL in (SELECT ...)" has not yet been evaluated
238
238
      FALSE   - result is FALSE
389
389
/*
390
390
  trigcond<param>(arg) ::= param? arg : TRUE
391
391
 
392
 
  The class Item_func_trig_cond is used for guarded predicates 
 
392
  The class Item_func_trig_cond is used for guarded predicates
393
393
  which are employed only for internal purposes.
394
394
  A guarded predicate is an object consisting of an a regular or
395
 
  a guarded predicate P and a pointer to a boolean guard variable g. 
 
395
  a guarded predicate P and a pointer to a boolean guard variable g.
396
396
  A guarded predicate P/g is evaluated to true if the value of the
397
397
  guard g is false, otherwise it is evaluated to the same value that
398
398
  the predicate P: val(P/g)= g ? val(P):true.
404
404
  the objects consisting of three elements: a predicate P, a pointer
405
405
  to a variable g and a firing value s with following evaluation
406
406
  rule: val(P/g,s)= g==s? val(P) : true. It will allow us to build only
407
 
  one item for the objects of the form P/g1/g2... 
 
407
  one item for the objects of the form P/g1/g2...
408
408
 
409
409
  Objects of this class are built only for query execution after
410
410
  the execution plan has been already selected. That's why this
411
 
  class needs only val_int out of generic methods. 
412
 
 
 
411
  class needs only val_int out of generic methods.
 
412
 
413
413
  Current uses of Item_func_trig_cond objects:
414
414
   - To wrap selection conditions when executing outer joins
415
415
   - To wrap condition that is pushed down into subquery
553
553
  int64_t val_int();
554
554
  enum Functype functype() const { return NE_FUNC; }
555
555
  cond_result eq_cmp_result() const { return COND_FALSE; }
556
 
  optimize_type select_optimize() const { return OPTIMIZE_KEY; } 
 
556
  optimize_type select_optimize() const { return OPTIMIZE_KEY; }
557
557
  const char *func_name() const { return "<>"; }
558
558
  Item *negated_item();
559
559
};
757
757
  uint32_t count;
758
758
  uint32_t used_count;
759
759
  in_vector() {}
760
 
  in_vector(uint32_t elements,uint32_t element_length,qsort2_cmp cmp_func, 
 
760
  in_vector(uint32_t elements,uint32_t element_length,qsort2_cmp cmp_func,
761
761
            const CHARSET_INFO * const cmp_coll)
762
762
    :base((char*) sql_calloc(elements*element_length)),
763
763
     size(element_length), compare(cmp_func), collation(cmp_coll),
770
770
    my_qsort2(base,used_count,size,compare, (void *) collation);
771
771
  }
772
772
  int find(Item *item);
773
 
  
774
 
  /* 
 
773
 
 
774
  /*
775
775
    Create an instance of Item_{type} (e.g. Item_decimal) constant object
776
776
    which type allows it to hold an element of this vector without any
777
777
    conversions.
780
780
    for every array element you get (i.e. this implements "FlyWeight" pattern)
781
781
  */
782
782
  virtual Item* create_item() { return NULL; }
783
 
  
 
783
 
784
784
  /*
785
785
    Store the value at position #pos into provided item object
786
786
    SYNOPSIS
790
790
              type that create_item() returns.
791
791
  */
792
792
  virtual void value_to_item(uint32_t, Item *) { }
793
 
  
 
793
 
794
794
  /* Compare values number pos1 and pos2 for equality */
795
795
  bool compare_elems(uint32_t pos1, uint32_t pos2)
796
796
  {
809
809
  void set(uint32_t pos,Item *item);
810
810
  unsigned char *get_value(Item *item);
811
811
  Item* create_item()
812
 
  { 
 
812
  {
813
813
    return new Item_string(collation);
814
814
  }
815
815
  void value_to_item(uint32_t pos, Item *item)
816
 
  {    
 
816
  {
817
817
    String *str=((String*) base)+pos;
818
818
    Item_string *to= (Item_string*)item;
819
819
    to->str_value= *str;
826
826
protected:
827
827
  /*
828
828
    Here we declare a temporary variable (tmp) of the same type as the
829
 
    elements of this vector. tmp is used in finding if a given value is in 
830
 
    the list. 
 
829
    elements of this vector. tmp is used in finding if a given value is in
 
830
    the list.
831
831
  */
832
 
  struct packed_int64_t 
 
832
  struct packed_int64_t
833
833
  {
834
834
    int64_t val;
835
835
    int64_t unsigned_flag;  // Use int64_t, not bool, to preserve alignment
838
838
  in_int64_t(uint32_t elements);
839
839
  void set(uint32_t pos,Item *item);
840
840
  unsigned char *get_value(Item *item);
841
 
  
 
841
 
842
842
  Item* create_item()
843
 
  { 
844
 
    /* 
845
 
      We're created a signed INT, this may not be correct in 
 
843
  {
 
844
    /*
 
845
      We're created a signed INT, this may not be correct in
846
846
      general case (see BUG#19342).
847
847
    */
848
848
    return new Item_int((int64_t)0);
891
891
  void set(uint32_t pos,Item *item);
892
892
  unsigned char *get_value(Item *item);
893
893
  Item *create_item()
894
 
  { 
 
894
  {
895
895
    return new Item_float(0.0, 0);
896
896
  }
897
897
  void value_to_item(uint32_t pos, Item *item)
910
910
  void set(uint32_t pos, Item *item);
911
911
  unsigned char *get_value(Item *item);
912
912
  Item *create_item()
913
 
  { 
 
913
  {
914
914
    return new Item_decimal(0, false);
915
915
  }
916
916
  void value_to_item(uint32_t pos, Item *item)
946
946
  }
947
947
};
948
948
 
949
 
class cmp_item_string :public cmp_item 
 
949
class cmp_item_string :public cmp_item
950
950
{
951
951
protected:
952
952
  String *value_res;
985
985
  {
986
986
    cmp_item_string *l_cmp= (cmp_item_string *) ci;
987
987
    return sortcmp(value_res, l_cmp->value_res, cmp_charset);
988
 
  } 
 
988
  }
989
989
  cmp_item *make_same();
990
990
  void set_charset(const CHARSET_INFO * const cs)
991
991
  {
1073
1073
};
1074
1074
 
1075
1075
 
1076
 
/* 
 
1076
/*
1077
1077
   cmp_item for optimized IN with row (right part string, which never
1078
1078
   be changed)
1079
1079
*/
1111
1111
  The class Item_func_case is the CASE ... WHEN ... THEN ... END function
1112
1112
  implementation.
1113
1113
 
1114
 
  When there is no expression between CASE and the first WHEN 
 
1114
  When there is no expression between CASE and the first WHEN
1115
1115
  (the CASE expression) then this function simple checks all WHEN expressions
1116
1116
  one after another. When some WHEN expression evaluated to TRUE then the
1117
1117
  value of the corresponding THEN expression is returned.
1191
1191
class Item_func_in :public Item_func_opt_neg
1192
1192
{
1193
1193
public:
1194
 
  /* 
 
1194
  /*
1195
1195
    an array of values when the right hand arguments of IN
1196
 
    are all SQL constant and there are no nulls 
 
1196
    are all SQL constant and there are no nulls
1197
1197
  */
1198
1198
  in_vector *array;
1199
1199
  bool have_null;
1200
 
  /* 
 
1200
  /*
1201
1201
    true when all arguments of the IN clause are of compatible types
1202
1202
    and can be used safely as comparisons for key conditions
1203
1203
  */
1315
1315
 
1316
1316
class Item_in_subselect;
1317
1317
 
1318
 
/* 
 
1318
/*
1319
1319
  This is like IS NOT NULL but it also remembers if it ever has
1320
1320
  encountered a NULL.
1321
1321
*/
1378
1378
  enum { alphabet_size = 256 };
1379
1379
 
1380
1380
  Item *escape_item;
1381
 
  
 
1381
 
1382
1382
  bool escape_used_in_parsing;
1383
1383
 
1384
1384
public:
1385
1385
  int escape;
1386
1386
 
1387
1387
  Item_func_like(Item *a,Item *b, Item *escape_arg, bool escape_used)
1388
 
    :Item_bool_func2(a,b), canDoTurboBM(false), pattern(0), pattern_len(0), 
 
1388
    :Item_bool_func2(a,b), canDoTurboBM(false), pattern(0), pattern_len(0),
1389
1389
     bmGs(0), bmBc(0), escape_item(escape_arg),
1390
1390
     escape_used_in_parsing(escape_used) {}
1391
1391
  int64_t val_int();
1465
1465
  A conjunction of the predicates f2=f1 and f3=f1 and f3=f2 will be
1466
1466
  substituted for the item representing the same multiple equality
1467
1467
  f1=f2=f3.
1468
 
  An item Item_equal(f1,f2) can appear instead of a conjunction of 
 
1468
  An item Item_equal(f1,f2) can appear instead of a conjunction of
1469
1469
  f2=f1 and f1=f2, or instead of just the predicate f1=f2.
1470
1470
 
1471
 
  An item of the class Item_equal inherits equalities from outer 
 
1471
  An item of the class Item_equal inherits equalities from outer
1472
1472
  conjunctive levels.
1473
1473
 
1474
1474
  Suppose we have a where condition of the following form:
1479
1479
    f1=f3 will be substituted for Item_equal(f1,f2,f3,f4,f5);
1480
1480
 
1481
1481
  An object of the class Item_equal can contain an optional constant
1482
 
  item c. Then it represents a multiple equality of the form 
 
1482
  item c. Then it represents a multiple equality of the form
1483
1483
  c=f1=...=fk.
1484
1484
 
1485
1485
  Objects of the class Item_equal are used for the following:
1494
1494
  It also can give us additional index scans and can allow us to
1495
1495
  improve selectivity estimates.
1496
1496
 
1497
 
  3. An object Item_equal(t1.f1,...,tk.fk) is used to optimize the 
1498
 
  selected execution plan for the query: if table ti is accessed 
 
1497
  3. An object Item_equal(t1.f1,...,tk.fk) is used to optimize the
 
1498
  selected execution plan for the query: if table ti is accessed
1499
1499
  before the table tj then in any predicate P in the where condition
1500
1500
  the occurrence of tj.fj is substituted for ti.fi. This can allow
1501
1501
  an evaluation of the predicate at an earlier step.
1502
1502
 
1503
 
  When feature 1 is supported they say that join transitive closure 
 
1503
  When feature 1 is supported they say that join transitive closure
1504
1504
  is employed.
1505
1505
  When feature 2 is supported they say that search argument transitive
1506
1506
  closure is employed.
1509
1509
  We do not just add predicates, we rather dynamically replace some
1510
1510
  predicates that can not be used to access tables in the investigated
1511
1511
  plan for those, obtained by substitution of some fields for equal fields,
1512
 
  that can be used.     
 
1512
  that can be used.
1513
1513
 
1514
1514
  Prepared Statements/Stored Procedures note: instances of class
1515
1515
  Item_equal are created only at the time a PS/SP is executed and
1545
1545
  void merge(Item_equal *item);
1546
1546
  void update_const();
1547
1547
  enum Functype functype() const { return MULT_EQUAL_FUNC; }
1548
 
  int64_t val_int(); 
 
1548
  int64_t val_int();
1549
1549
  const char *func_name() const { return "multiple equal"; }
1550
1550
  optimize_type select_optimize() const { return OPTIMIZE_EQUAL; }
1551
1551
  void sort(Item_field_cmpfunc cmp, void *arg);
1556
1556
  bool walk(Item_processor processor, bool walk_subquery, unsigned char *arg);
1557
1557
  Item *transform(Item_transformer transformer, unsigned char *arg);
1558
1558
  virtual void print(String *str, enum_query_type query_type);
1559
 
  const CHARSET_INFO *compare_collation() 
 
1559
  const CHARSET_INFO *compare_collation()
1560
1560
  { return fields.head()->collation.collation; }
1561
 
}; 
 
1561
};
1562
1562
 
1563
1563
class COND_EQUAL: public Sql_alloc
1564
1564
{
1565
1565
public:
1566
1566
  uint32_t max_members;               /* max number of members the current level
1567
 
                                     list and all lower level lists */ 
 
1567
                                     list and all lower level lists */
1568
1568
  COND_EQUAL *upper_levels;       /* multiple equalities of upper and levels */
1569
 
  List<Item_equal> current_level; /* list of multiple equalities of 
 
1569
  List<Item_equal> current_level; /* list of multiple equalities of
1570
1570
                                     the current and level           */
1571
1571
  COND_EQUAL()
1572
 
  { 
 
1572
  {
1573
1573
    upper_levels= 0;
1574
1574
  }
1575
1575
};
1578
1578
class Item_equal_iterator : public List_iterator_fast<Item_field>
1579
1579
{
1580
1580
public:
1581
 
  inline Item_equal_iterator(Item_equal &item_equal) 
 
1581
  inline Item_equal_iterator(Item_equal &item_equal)
1582
1582
    :List_iterator_fast<Item_field> (item_equal.fields)
1583
1583
  {}
1584
1584
  inline Item_field* operator++(int)
1585
 
  { 
 
1585
  {
1586
1586
    Item_field *item= (*(List_iterator_fast<Item_field> *) this)++;
1587
1587
    return  item;
1588
1588
  }
1589
 
  inline void rewind(void) 
1590
 
  { 
 
1589
  inline void rewind(void)
 
1590
  {
1591
1591
    List_iterator_fast<Item_field>::rewind();
1592
1592
  }
1593
1593
};
1595
1595
class Item_cond_and :public Item_cond
1596
1596
{
1597
1597
public:
1598
 
  COND_EQUAL cond_equal;  /* contains list of Item_equal objects for 
 
1598
  COND_EQUAL cond_equal;  /* contains list of Item_equal objects for
1599
1599
                             the current and level and reference
1600
 
                             to multiple equalities of upper and levels */  
 
1600
                             to multiple equalities of upper and levels */
1601
1601
  Item_cond_and() :Item_cond() {}
1602
1602
  Item_cond_and(Item *i1,Item *i2) :Item_cond(i1,i2) {}
1603
1603
  Item_cond_and(Session *session, Item_cond_and *item) :Item_cond(session, item) {}