item_cmpfunc.h 48.2 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000-2003 MySQL AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
unknown's avatar
unknown committed
6

unknown's avatar
unknown committed
7 8 9 10
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
unknown's avatar
unknown committed
11

unknown's avatar
unknown committed
12 13 14 15 16 17 18
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/* compare and test functions */

19
#ifdef USE_PRAGMA_INTERFACE
unknown's avatar
unknown committed
20 21 22
#pragma interface			/* gcc class implementation */
#endif

23 24 25 26 27 28
extern Item_result item_cmp_type(Item_result a,Item_result b);
class Item_bool_func2;
class Arg_comparator;

typedef int (Arg_comparator::*arg_cmp_func)();

unknown's avatar
unknown committed
29 30
typedef int (*Item_field_cmpfunc)(Item_field *f1, Item_field *f2, void *arg); 

31 32 33 34 35 36
class Arg_comparator: public Sql_alloc
{
  Item **a, **b;
  arg_cmp_func func;
  Item_bool_func2 *owner;
  Arg_comparator *comparators;   // used only for compare_row()
37
  double precision;
38 39 40 41 42 43 44
  /* Fields used in DATE/DATETIME comparison. */
  THD *thd;
  enum_field_types a_type, b_type; // Types of a and b items
  Item *a_cache, *b_cache;         // Cached values of a and b items
  bool is_nulls_eq;                // TRUE <=> compare for the EQUAL_FUNC
  enum enum_date_cmp_type { CMP_DATE_DFLT= 0, CMP_DATE_WITH_DATE,
                            CMP_DATE_WITH_STR, CMP_STR_WITH_DATE };
unknown's avatar
unknown committed
45 46
  ulonglong (*get_value_func)(THD *thd, Item ***item_arg, Item **cache_arg,
                              Item *warn_item, bool *is_null);
47
public:
48 49
  DTCollation cmp_collation;

50 51 52
  Arg_comparator(): thd(0), a_cache(0), b_cache(0) {};
  Arg_comparator(Item **a1, Item **a2): a(a1), b(a2), thd(0),
    a_cache(0), b_cache(0) {};
53 54

  int set_compare_func(Item_bool_func2 *owner, Item_result type);
55
  inline int set_compare_func(Item_bool_func2 *owner_arg)
56
  {
unknown's avatar
unknown committed
57 58
    return set_compare_func(owner_arg, item_cmp_type((*a)->result_type(),
                                                     (*b)->result_type()));
59
  }
60
  int set_cmp_func(Item_bool_func2 *owner_arg,
61
			  Item **a1, Item **a2,
62 63
			  Item_result type);

64
  inline int set_cmp_func(Item_bool_func2 *owner_arg,
65 66
			  Item **a1, Item **a2)
  {
unknown's avatar
unknown committed
67 68 69
    return set_cmp_func(owner_arg, a1, a2,
                        item_cmp_type((*a1)->result_type(),
                                      (*a2)->result_type()));
70 71 72 73
  }
  inline int compare() { return (this->*func)(); }

  int compare_string();		 // compare args[0] & args[1]
unknown's avatar
unknown committed
74
  int compare_binary_string();	 // compare args[0] & args[1]
75
  int compare_real();            // compare args[0] & args[1]
unknown's avatar
unknown committed
76
  int compare_decimal();         // compare args[0] & args[1]
77
  int compare_int_signed();      // compare args[0] & args[1]
78 79 80
  int compare_int_signed_unsigned();
  int compare_int_unsigned_signed();
  int compare_int_unsigned();
81 82
  int compare_row();             // compare args[0] & args[1]
  int compare_e_string();	 // compare args[0] & args[1]
unknown's avatar
unknown committed
83
  int compare_e_binary_string(); // compare args[0] & args[1]
84
  int compare_e_real();          // compare args[0] & args[1]
unknown's avatar
unknown committed
85
  int compare_e_decimal();       // compare args[0] & args[1]
86
  int compare_e_int();           // compare args[0] & args[1]
87
  int compare_e_int_diff_signedness();
88
  int compare_e_row();           // compare args[0] & args[1]
89 90
  int compare_real_fixed();
  int compare_e_real_fixed();
91 92 93 94
  int compare_datetime();        // compare args[0] & args[1] as DATETIMEs

  static enum enum_date_cmp_type can_compare_as_dates(Item *a, Item *b,
                                                      ulonglong *const_val_arg);
95

96
  void set_datetime_cmp_func(Item **a1, Item **b1);
unknown's avatar
unknown committed
97
  static arg_cmp_func comparator_matrix [5][2];
98 99 100 101

  friend class Item_func;
};

unknown's avatar
unknown committed
102 103 104 105 106 107
class Item_bool_func :public Item_int_func
{
public:
  Item_bool_func() :Item_int_func() {}
  Item_bool_func(Item *a) :Item_int_func(a) {}
  Item_bool_func(Item *a,Item *b) :Item_int_func(a,b) {}
108
  Item_bool_func(THD *thd, Item_bool_func *item) :Item_int_func(thd, item) {}
unknown's avatar
unknown committed
109
  bool is_bool_func() { return 1; }
unknown's avatar
unknown committed
110
  void fix_length_and_dec() { decimals=0; max_length=1; }
unknown's avatar
unknown committed
111
  uint decimal_precision() const { return 1; }
unknown's avatar
unknown committed
112 113
};

114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199

/**
  Abstract Item class, to represent <code>X IS [NOT] (TRUE | FALSE)</code>
  boolean predicates.
*/

class Item_func_truth : public Item_bool_func
{
public:
  virtual bool val_bool();
  virtual longlong val_int();
  virtual void fix_length_and_dec();
  virtual void print(String *str);

protected:
  Item_func_truth(Item *a, bool a_value, bool a_affirmative)
  : Item_bool_func(a), value(a_value), affirmative(a_affirmative)
  {}

  ~Item_func_truth()
  {}
private:
  /**
    True for <code>X IS [NOT] TRUE</code>,
    false for <code>X IS [NOT] FALSE</code> predicates.
  */
  const bool value;
  /**
    True for <code>X IS Y</code>, false for <code>X IS NOT Y</code> predicates.
  */
  const bool affirmative;
};


/**
  This Item represents a <code>X IS TRUE</code> boolean predicate.
*/

class Item_func_istrue : public Item_func_truth
{
public:
  Item_func_istrue(Item *a) : Item_func_truth(a, true, true) {}
  ~Item_func_istrue() {}
  virtual const char* func_name() const { return "istrue"; }
};


/**
  This Item represents a <code>X IS NOT TRUE</code> boolean predicate.
*/

class Item_func_isnottrue : public Item_func_truth
{
public:
  Item_func_isnottrue(Item *a) : Item_func_truth(a, true, false) {}
  ~Item_func_isnottrue() {}
  virtual const char* func_name() const { return "isnottrue"; }
};


/**
  This Item represents a <code>X IS FALSE</code> boolean predicate.
*/

class Item_func_isfalse : public Item_func_truth
{
public:
  Item_func_isfalse(Item *a) : Item_func_truth(a, false, true) {}
  ~Item_func_isfalse() {}
  virtual const char* func_name() const { return "isfalse"; }
};


/**
  This Item represents a <code>X IS NOT FALSE</code> boolean predicate.
*/

class Item_func_isnotfalse : public Item_func_truth
{
public:
  Item_func_isnotfalse(Item *a) : Item_func_truth(a, false, false) {}
  ~Item_func_isnotfalse() {}
  virtual const char* func_name() const { return "isnotfalse"; }
};


200
class Item_cache;
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
#define UNKNOWN ((my_bool)-1)


/*
  Item_in_optimizer(left_expr, Item_in_subselect(...))

  Item_in_optimizer is used to wrap an instance of Item_in_subselect. This
  class does the following:
   - Evaluate the left expression and store it in Item_cache_* object (to
     avoid re-evaluating it many times during subquery execution)
   - Shortcut the evaluation of "NULL IN (...)" to NULL in the cases where we
     don't care if the result is NULL or FALSE.

  NOTE
    It is not quite clear why the above listed functionality should be
    placed into a separate class called 'Item_in_optimizer'.
*/

219 220 221
class Item_in_optimizer: public Item_bool_func
{
protected:
222
  Item_cache *cache;
223
  bool save_cache;
224 225 226 227 228 229 230
  /* 
    Stores the value of "NULL IN (SELECT ...)" for uncorrelated subqueries:
      UNKNOWN - "NULL in (SELECT ...)" has not yet been evaluated
      FALSE   - result is FALSE
      TRUE    - result is NULL
  */
  my_bool result_for_null_param;
231
public:
unknown's avatar
unknown committed
232
  Item_in_optimizer(Item *a, Item_in_subselect *b):
233 234
    Item_bool_func(a, my_reinterpret_cast(Item *)(b)), cache(0),
    save_cache(0), result_for_null_param(UNKNOWN)
235
  {}
236 237
  bool fix_fields(THD *, Item **);
  bool fix_left(THD *thd, Item **ref);
238
  bool is_null();
239
  longlong val_int();
unknown's avatar
unknown committed
240
  void cleanup();
241
  const char *func_name() const { return "<in_optimizer>"; }
unknown's avatar
unknown committed
242
  Item_cache **get_cache() { return &cache; }
243
  void keep_top_level_cache();
244 245
};

unknown's avatar
unknown committed
246 247 248
class Comp_creator
{
public:
249 250
  Comp_creator() {}                           /* Remove gcc warning */
  virtual ~Comp_creator() {}                  /* Remove gcc warning */
unknown's avatar
unknown committed
251 252 253 254 255 256 257 258 259
  virtual Item_bool_func2* create(Item *a, Item *b) const = 0;
  virtual const char* symbol(bool invert) const = 0;
  virtual bool eqne_op() const = 0;
  virtual bool l_op() const = 0;
};

class Eq_creator :public Comp_creator
{
public:
260 261
  Eq_creator() {}                             /* Remove gcc warning */
  virtual ~Eq_creator() {}                    /* Remove gcc warning */
unknown's avatar
unknown committed
262 263 264 265 266 267 268 269 270
  virtual Item_bool_func2* create(Item *a, Item *b) const;
  virtual const char* symbol(bool invert) const { return invert? "<>" : "="; }
  virtual bool eqne_op() const { return 1; }
  virtual bool l_op() const { return 0; }
};

class Ne_creator :public Comp_creator
{
public:
271 272
  Ne_creator() {}                             /* Remove gcc warning */
  virtual ~Ne_creator() {}                    /* Remove gcc warning */
unknown's avatar
unknown committed
273 274 275 276 277 278 279 280 281
  virtual Item_bool_func2* create(Item *a, Item *b) const;
  virtual const char* symbol(bool invert) const { return invert? "=" : "<>"; }
  virtual bool eqne_op() const { return 1; }
  virtual bool l_op() const { return 0; }
};

class Gt_creator :public Comp_creator
{
public:
282 283
  Gt_creator() {}                             /* Remove gcc warning */
  virtual ~Gt_creator() {}                    /* Remove gcc warning */
unknown's avatar
unknown committed
284 285 286 287 288 289 290 291 292
  virtual Item_bool_func2* create(Item *a, Item *b) const;
  virtual const char* symbol(bool invert) const { return invert? "<=" : ">"; }
  virtual bool eqne_op() const { return 0; }
  virtual bool l_op() const { return 0; }
};

class Lt_creator :public Comp_creator
{
public:
293 294
  Lt_creator() {}                             /* Remove gcc warning */
  virtual ~Lt_creator() {}                    /* Remove gcc warning */
unknown's avatar
unknown committed
295 296 297 298 299 300 301 302 303
  virtual Item_bool_func2* create(Item *a, Item *b) const;
  virtual const char* symbol(bool invert) const { return invert? ">=" : "<"; }
  virtual bool eqne_op() const { return 0; }
  virtual bool l_op() const { return 1; }
};

class Ge_creator :public Comp_creator
{
public:
304 305
  Ge_creator() {}                             /* Remove gcc warning */
  virtual ~Ge_creator() {}                    /* Remove gcc warning */
unknown's avatar
unknown committed
306 307 308 309 310 311 312 313 314
  virtual Item_bool_func2* create(Item *a, Item *b) const;
  virtual const char* symbol(bool invert) const { return invert? "<" : ">="; }
  virtual bool eqne_op() const { return 0; }
  virtual bool l_op() const { return 0; }
};

class Le_creator :public Comp_creator
{
public:
315 316
  Le_creator() {}                             /* Remove gcc warning */
  virtual ~Le_creator() {}                    /* Remove gcc warning */
unknown's avatar
unknown committed
317 318 319 320 321 322
  virtual Item_bool_func2* create(Item *a, Item *b) const;
  virtual const char* symbol(bool invert) const { return invert? ">" : "<="; }
  virtual bool eqne_op() const { return 0; }
  virtual bool l_op() const { return 1; }
};

unknown's avatar
unknown committed
323 324 325
class Item_bool_func2 :public Item_int_func
{						/* Bool with 2 string args */
protected:
326
  Arg_comparator cmp;
unknown's avatar
unknown committed
327
  String tmp_value1,tmp_value2;
328
  bool abort_on_null;
329

unknown's avatar
unknown committed
330
public:
331
  Item_bool_func2(Item *a,Item *b)
332
    :Item_int_func(a,b), cmp(tmp_arg, tmp_arg+1), abort_on_null(FALSE) {}
unknown's avatar
unknown committed
333
  void fix_length_and_dec();
334
  void set_cmp_func()
unknown's avatar
unknown committed
335
  {
336
    cmp.set_cmp_func(this, tmp_arg, tmp_arg+1);
unknown's avatar
unknown committed
337
  }
unknown's avatar
unknown committed
338 339 340 341
  optimize_type select_optimize() const { return OPTIMIZE_OP; }
  virtual enum Functype rev_functype() const { return UNKNOWN_FUNC; }
  bool have_rev_func() const { return rev_functype() != UNKNOWN_FUNC; }
  void print(String *str) { Item_func::print_op(str); }
unknown's avatar
unknown committed
342
  bool is_null() { return test(args[0]->is_null() || args[1]->is_null()); }
unknown's avatar
unknown committed
343
  bool is_bool_func() { return 1; }
344
  CHARSET_INFO *compare_collation() { return cmp.cmp_collation.collation; }
unknown's avatar
unknown committed
345
  uint decimal_precision() const { return 1; }
346
  void top_level_item() { abort_on_null= TRUE; }
unknown's avatar
unknown committed
347

348
  friend class  Arg_comparator;
unknown's avatar
unknown committed
349 350
};

unknown's avatar
unknown committed
351 352 353
class Item_bool_rowready_func2 :public Item_bool_func2
{
public:
354
  Item_bool_rowready_func2(Item *a, Item *b) :Item_bool_func2(a, b)
unknown's avatar
unknown committed
355
  {
356
    allowed_arg_cols= 0;  // Fetch this value from first argument
unknown's avatar
unknown committed
357
  }
358 359
  Item *neg_transformer(THD *thd);
  virtual Item *negated_item();
360
  bool subst_argument_checker(byte **arg) { return TRUE; }
unknown's avatar
unknown committed
361
};
unknown's avatar
unknown committed
362 363 364 365 366 367

class Item_func_not :public Item_bool_func
{
public:
  Item_func_not(Item *a) :Item_bool_func(a) {}
  longlong val_int();
368
  enum Functype functype() const { return NOT_FUNC; }
unknown's avatar
unknown committed
369
  const char *func_name() const { return "not"; }
370
  Item *neg_transformer(THD *thd);
371
  void print(String *str);
unknown's avatar
unknown committed
372 373
};

374
class Item_maxmin_subselect;
375 376

/*
377 378
  trigcond<param>(arg) ::= param? arg : TRUE

379 380
  The class Item_func_trig_cond is used for guarded predicates 
  which are employed only for internal purposes.
381
  A guarded predicate is an object consisting of an a regular or
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
  a guarded predicate P and a pointer to a boolean guard variable g. 
  A guarded predicate P/g is evaluated to true if the value of the
  guard g is false, otherwise it is evaluated to the same value that
  the predicate P: val(P/g)= g ? val(P):true.
  Guarded predicates allow us to include predicates into a conjunction
  conditionally. Currently they are utilized for pushed down predicates
  in queries with outer join operations.

  In the future, probably, it makes sense to extend this class to
  the objects consisting of three elements: a predicate P, a pointer
  to a variable g and a firing value s with following evaluation
  rule: val(P/g,s)= g==s? val(P) : true. It will allow us to build only
  one item for the objects of the form P/g1/g2... 

  Objects of this class are built only for query execution after
  the execution plan has been already selected. That's why this
  class needs only val_int out of generic methods. 
399 400 401 402
 
  Current uses of Item_func_trig_cond objects:
   - To wrap selection conditions when executing outer joins
   - To wrap condition that is pushed down into subquery
403 404 405 406 407 408 409 410 411 412
*/

class Item_func_trig_cond: public Item_bool_func
{
  bool *trig_var;
public:
  Item_func_trig_cond(Item *a, bool *f) : Item_bool_func(a) { trig_var= f; }
  longlong val_int() { return *trig_var ? args[0]->val_int() : 1; }
  enum Functype functype() const { return TRIG_COND_FUNC; };
  const char *func_name() const { return "trigcond"; };
413
  bool const_item() const { return FALSE; }
414
  bool *get_trig_var() { return trig_var; }
415 416
};

417 418
class Item_func_not_all :public Item_func_not
{
unknown's avatar
unknown committed
419
  /* allow to check presence of values in max/min optimization */
420 421 422
  Item_sum_hybrid *test_sum_item;
  Item_maxmin_subselect *test_sub_item;

423 424
  bool abort_on_null;
public:
unknown's avatar
unknown committed
425 426
  bool show;

427 428 429 430
  Item_func_not_all(Item *a)
    :Item_func_not(a), test_sum_item(0), test_sub_item(0), abort_on_null(0),
     show(0)
    {}
431 432 433
  virtual void top_level_item() { abort_on_null= 1; }
  bool top_level() { return abort_on_null; }
  longlong val_int();
434
  enum Functype functype() const { return NOT_ALL_FUNC; }
unknown's avatar
unknown committed
435 436
  const char *func_name() const { return "<not>"; }
  void print(String *str);
437 438 439
  void set_sum_test(Item_sum_hybrid *item) { test_sum_item= item; };
  void set_sub_test(Item_maxmin_subselect *item) { test_sub_item= item; };
  bool empty_underlying_subquery();
440
  Item *neg_transformer(THD *thd);
441 442
};

443 444 445 446 447 448 449 450

class Item_func_nop_all :public Item_func_not_all
{
public:

  Item_func_nop_all(Item *a) :Item_func_not_all(a) {}
  longlong val_int();
  const char *func_name() const { return "<nop>"; }
451
  Item *neg_transformer(THD *thd);
452 453 454
};


unknown's avatar
unknown committed
455
class Item_func_eq :public Item_bool_rowready_func2
unknown's avatar
unknown committed
456 457
{
public:
458
  Item_func_eq(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {}
unknown's avatar
unknown committed
459 460 461 462 463
  longlong val_int();
  enum Functype functype() const { return EQ_FUNC; }
  enum Functype rev_functype() const { return EQ_FUNC; }
  cond_result eq_cmp_result() const { return COND_TRUE; }
  const char *func_name() const { return "="; }
464
  Item *negated_item();
unknown's avatar
unknown committed
465 466
};

unknown's avatar
unknown committed
467
class Item_func_equal :public Item_bool_rowready_func2
unknown's avatar
unknown committed
468 469
{
public:
unknown's avatar
unknown committed
470
  Item_func_equal(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {};
unknown's avatar
unknown committed
471
  longlong val_int();
unknown's avatar
unknown committed
472
  void fix_length_and_dec();
473
  table_map not_null_tables() const { return 0; }
unknown's avatar
unknown committed
474 475 476 477
  enum Functype functype() const { return EQUAL_FUNC; }
  enum Functype rev_functype() const { return EQUAL_FUNC; }
  cond_result eq_cmp_result() const { return COND_TRUE; }
  const char *func_name() const { return "<=>"; }
478
  Item *neg_transformer(THD *thd) { return 0; }
unknown's avatar
unknown committed
479 480 481
};


unknown's avatar
unknown committed
482
class Item_func_ge :public Item_bool_rowready_func2
unknown's avatar
unknown committed
483 484
{
public:
485
  Item_func_ge(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {};
unknown's avatar
unknown committed
486 487 488 489 490
  longlong val_int();
  enum Functype functype() const { return GE_FUNC; }
  enum Functype rev_functype() const { return LE_FUNC; }
  cond_result eq_cmp_result() const { return COND_TRUE; }
  const char *func_name() const { return ">="; }
491
  Item *negated_item();
unknown's avatar
unknown committed
492 493 494
};


unknown's avatar
unknown committed
495
class Item_func_gt :public Item_bool_rowready_func2
unknown's avatar
unknown committed
496 497
{
public:
498
  Item_func_gt(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {};
unknown's avatar
unknown committed
499 500 501 502 503
  longlong val_int();
  enum Functype functype() const { return GT_FUNC; }
  enum Functype rev_functype() const { return LT_FUNC; }
  cond_result eq_cmp_result() const { return COND_FALSE; }
  const char *func_name() const { return ">"; }
504
  Item *negated_item();
unknown's avatar
unknown committed
505 506 507
};


unknown's avatar
unknown committed
508
class Item_func_le :public Item_bool_rowready_func2
unknown's avatar
unknown committed
509 510
{
public:
511
  Item_func_le(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {};
unknown's avatar
unknown committed
512 513 514 515 516
  longlong val_int();
  enum Functype functype() const { return LE_FUNC; }
  enum Functype rev_functype() const { return GE_FUNC; }
  cond_result eq_cmp_result() const { return COND_TRUE; }
  const char *func_name() const { return "<="; }
517
  Item *negated_item();
unknown's avatar
unknown committed
518 519 520
};


unknown's avatar
unknown committed
521
class Item_func_lt :public Item_bool_rowready_func2
unknown's avatar
unknown committed
522 523
{
public:
524
  Item_func_lt(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {}
unknown's avatar
unknown committed
525 526 527 528 529
  longlong val_int();
  enum Functype functype() const { return LT_FUNC; }
  enum Functype rev_functype() const { return GT_FUNC; }
  cond_result eq_cmp_result() const { return COND_FALSE; }
  const char *func_name() const { return "<"; }
530
  Item *negated_item();
unknown's avatar
unknown committed
531 532 533
};


unknown's avatar
unknown committed
534
class Item_func_ne :public Item_bool_rowready_func2
unknown's avatar
unknown committed
535 536
{
public:
537
  Item_func_ne(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {}
unknown's avatar
unknown committed
538 539 540
  longlong val_int();
  enum Functype functype() const { return NE_FUNC; }
  cond_result eq_cmp_result() const { return COND_FALSE; }
unknown's avatar
unknown committed
541
  optimize_type select_optimize() const { return OPTIMIZE_KEY; } 
unknown's avatar
unknown committed
542
  const char *func_name() const { return "<>"; }
543
  Item *negated_item();
unknown's avatar
unknown committed
544 545 546
};


unknown's avatar
unknown committed
547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
/*
  The class Item_func_opt_neg is defined to factor out the functionality
  common for the classes Item_func_between and Item_func_in. The objects
  of these classes can express predicates or there negations.
  The alternative approach would be to create pairs Item_func_between,
  Item_func_notbetween and Item_func_in, Item_func_notin.

*/

class Item_func_opt_neg :public Item_int_func
{
public:
  bool negated;     /* <=> the item represents NOT <func> */
  bool pred_level;  /* <=> [NOT] <func> is used on a predicate level */
public:
  Item_func_opt_neg(Item *a, Item *b, Item *c)
    :Item_int_func(a, b, c), negated(0), pred_level(0) {}
  Item_func_opt_neg(List<Item> &list)
    :Item_int_func(list), negated(0), pred_level(0) {}
public:
  inline void negate() { negated= !negated; }
  inline void top_level_item() { pred_level= 1; }
  Item *neg_transformer(THD *thd)
  {
    negated= !negated;
    return this;
  }
574
  bool eq(const Item *item, bool binary_cmp) const;
unknown's avatar
unknown committed
575
  bool subst_argument_checker(byte **arg) { return TRUE; }
unknown's avatar
unknown committed
576 577 578 579
};


class Item_func_between :public Item_func_opt_neg
unknown's avatar
unknown committed
580
{
581
  DTCollation cmp_collation;
unknown's avatar
unknown committed
582 583 584
public:
  Item_result cmp_type;
  String value0,value1,value2;
585 586 587 588
  /* TRUE <=> arguments will be compared as dates. */
  bool compare_as_dates;
  /* Comparators used for DATE/DATETIME comparison. */
  Arg_comparator ge_cmp, le_cmp;
unknown's avatar
unknown committed
589
  Item_func_between(Item *a, Item *b, Item *c)
590
    :Item_func_opt_neg(a, b, c), compare_as_dates(FALSE) {}
unknown's avatar
unknown committed
591 592 593 594
  longlong val_int();
  optimize_type select_optimize() const { return OPTIMIZE_KEY; }
  enum Functype functype() const   { return BETWEEN; }
  const char *func_name() const { return "between"; }
595
  bool fix_fields(THD *, Item **);
unknown's avatar
unknown committed
596
  void fix_length_and_dec();
597
  void print(String *str);
unknown's avatar
unknown committed
598
  bool is_bool_func() { return 1; }
599
  CHARSET_INFO *compare_collation() { return cmp_collation.collation; }
unknown's avatar
unknown committed
600
  uint decimal_precision() const { return 1; }
unknown's avatar
unknown committed
601 602 603 604 605 606 607 608 609 610
};


class Item_func_strcmp :public Item_bool_func2
{
public:
  Item_func_strcmp(Item *a,Item *b) :Item_bool_func2(a,b) {}
  longlong val_int();
  optimize_type select_optimize() const { return OPTIMIZE_NONE; }
  const char *func_name() const { return "strcmp"; }
611
  void print(String *str) { Item_func::print(str); }
unknown's avatar
unknown committed
612 613 614
};


unknown's avatar
unknown committed
615 616 617 618 619 620 621
struct interval_range
{
  Item_result type;
  double dbl;
  my_decimal dec;
};

unknown's avatar
unknown committed
622 623
class Item_func_interval :public Item_int_func
{
624
  Item_row *row;
unknown's avatar
unknown committed
625 626
  my_bool use_decimal_comparison;
  interval_range *intervals;
unknown's avatar
unknown committed
627
public:
628
  Item_func_interval(Item_row *a)
629 630 631 632
    :Item_int_func(a),row(a),intervals(0)
  {
    allowed_arg_cols= 0;    // Fetch this value from first argument
  }
unknown's avatar
unknown committed
633 634 635
  longlong val_int();
  void fix_length_and_dec();
  const char *func_name() const { return "interval"; }
unknown's avatar
unknown committed
636
  uint decimal_precision() const { return 2; }
unknown's avatar
unknown committed
637 638 639
};


unknown's avatar
unknown committed
640
class Item_func_coalesce :public Item_func_numhybrid
unknown's avatar
unknown committed
641
{
unknown's avatar
unknown committed
642
protected:
unknown's avatar
unknown committed
643
  Item_func_coalesce(Item *a, Item *b) :Item_func_numhybrid(a, b) {}
unknown's avatar
unknown committed
644
public:
unknown's avatar
unknown committed
645 646 647 648 649
  Item_func_coalesce(List<Item> &list) :Item_func_numhybrid(list) {}
  double real_op();
  longlong int_op();
  String *str_op(String *);
  my_decimal *decimal_op(my_decimal *);
unknown's avatar
unknown committed
650
  void fix_length_and_dec();
unknown's avatar
unknown committed
651 652
  void find_num_type() {}
  enum Item_result result_type () const { return hybrid_type; }
unknown's avatar
unknown committed
653 654 655 656 657 658 659 660
  const char *func_name() const { return "coalesce"; }
  table_map not_null_tables() const { return 0; }
};


class Item_func_ifnull :public Item_func_coalesce
{
protected:
661 662
  enum_field_types cached_field_type;
  bool field_type_defined;
unknown's avatar
unknown committed
663
public:
unknown's avatar
unknown committed
664
  Item_func_ifnull(Item *a, Item *b) :Item_func_coalesce(a,b) {}
unknown's avatar
unknown committed
665 666 667 668
  double real_op();
  longlong int_op();
  String *str_op(String *str);
  my_decimal *decimal_op(my_decimal *);
669
  enum_field_types field_type() const;
unknown's avatar
unknown committed
670 671
  void fix_length_and_dec();
  const char *func_name() const { return "ifnull"; }
672
  Field *tmp_table_field(TABLE *table);
unknown's avatar
unknown committed
673
  uint decimal_precision() const;
unknown's avatar
unknown committed
674 675 676 677 678 679 680
};


class Item_func_if :public Item_func
{
  enum Item_result cached_result_type;
public:
681 682 683
  Item_func_if(Item *a,Item *b,Item *c)
    :Item_func(a,b,c), cached_result_type(INT_RESULT)
  {}
684
  double val_real();
unknown's avatar
unknown committed
685 686
  longlong val_int();
  String *val_str(String *str);
unknown's avatar
unknown committed
687
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
688
  enum Item_result result_type () const { return cached_result_type; }
689
  bool fix_fields(THD *, Item **);
unknown's avatar
unknown committed
690
  void fix_length_and_dec();
unknown's avatar
unknown committed
691
  uint decimal_precision() const;
unknown's avatar
unknown committed
692 693 694 695 696 697 698 699
  const char *func_name() const { return "if"; }
};


class Item_func_nullif :public Item_bool_func2
{
  enum Item_result cached_result_type;
public:
700 701 702
  Item_func_nullif(Item *a,Item *b)
    :Item_bool_func2(a,b), cached_result_type(INT_RESULT)
  {}
703
  double val_real();
unknown's avatar
unknown committed
704 705
  longlong val_int();
  String *val_str(String *str);
unknown's avatar
unknown committed
706
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
707 708
  enum Item_result result_type () const { return cached_result_type; }
  void fix_length_and_dec();
unknown's avatar
unknown committed
709
  uint decimal_precision() const { return args[0]->decimal_precision(); }
unknown's avatar
unknown committed
710
  const char *func_name() const { return "nullif"; }
711
  void print(String *str) { Item_func::print(str); }
712
  table_map not_null_tables() const { return 0; }
713
  bool is_null();
unknown's avatar
unknown committed
714 715 716 717 718
};


class Item_func_case :public Item_func
{
719
  int first_expr_num, else_expr_num;
unknown's avatar
unknown committed
720 721
  enum Item_result cached_result_type;
  String tmp_value;
722
  uint ncases;
723 724
  Item_result cmp_type;
  DTCollation cmp_collation;
unknown's avatar
unknown committed
725
public:
726
  Item_func_case(List<Item> &list, Item *first_expr_arg, Item *else_expr_arg)
727
    :Item_func(), first_expr_num(-1), else_expr_num(-1),
728
    cached_result_type(INT_RESULT)
unknown's avatar
unknown committed
729
  {
730 731 732 733 734 735 736 737 738 739 740 741 742
    ncases= list.elements;
    if (first_expr_arg)
    {
      first_expr_num= list.elements;
      list.push_back(first_expr_arg);
    }
    if (else_expr_arg)
    {
      else_expr_num= list.elements;
      list.push_back(else_expr_arg);
    }
    set_arguments(list);
  }
743
  double val_real();
unknown's avatar
unknown committed
744 745
  longlong val_int();
  String *val_str(String *);
unknown's avatar
unknown committed
746
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
747
  bool fix_fields(THD *thd, Item **ref);
unknown's avatar
unknown committed
748
  void fix_length_and_dec();
unknown's avatar
unknown committed
749
  uint decimal_precision() const;
750
  table_map not_null_tables() const { return 0; }
unknown's avatar
unknown committed
751 752 753 754
  enum Item_result result_type () const { return cached_result_type; }
  const char *func_name() const { return "case"; }
  void print(String *str);
  Item *find_item(String *str);
755
  CHARSET_INFO *compare_collation() { return cmp_collation.collation; }
unknown's avatar
unknown committed
756 757 758 759 760
};


/* Functions to handle the optimized IN */

761 762 763

/* A vector of values of some type  */

unknown's avatar
unknown committed
764 765
class in_vector :public Sql_alloc
{
766
public:
unknown's avatar
unknown committed
767 768
  char *base;
  uint size;
769 770
  qsort2_cmp compare;
  CHARSET_INFO *collation;
unknown's avatar
unknown committed
771 772
  uint count;
  uint used_count;
unknown's avatar
unknown committed
773
  in_vector() {}
774 775
  in_vector(uint elements,uint element_length,qsort2_cmp cmp_func, 
  	    CHARSET_INFO *cmp_coll)
unknown's avatar
unknown committed
776
    :base((char*) sql_calloc(elements*element_length)),
777 778
     size(element_length), compare(cmp_func), collation(cmp_coll),
     count(elements), used_count(elements) {}
unknown's avatar
unknown committed
779 780 781 782
  virtual ~in_vector() {}
  virtual void set(uint pos,Item *item)=0;
  virtual byte *get_value(Item *item)=0;
  void sort()
783
  {
784
    qsort2(base,used_count,size,compare,collation);
785
  }
unknown's avatar
unknown committed
786
  int find(Item *item);
787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
  
  /* 
    Create an instance of Item_{type} (e.g. Item_decimal) constant object
    which type allows it to hold an element of this vector without any
    conversions.
    The purpose of this function is to be able to get elements of this
    vector in form of Item_xxx constants without creating Item_xxx object
    for every array element you get (i.e. this implements "FlyWeight" pattern)
  */
  virtual Item* create_item() { return NULL; }
  
  /*
    Store the value at position #pos into provided item object
    SYNOPSIS
      value_to_item()
        pos   Index of value to store
        item  Constant item to store value into. The item must be of the same
              type that create_item() returns.
  */
  virtual void value_to_item(uint pos, Item *item) { }
  
  /* Compare values number pos1 and pos2 for equality */
  bool compare_elems(uint pos1, uint pos2)
  {
    return test(compare(collation, base + pos1*size, base + pos2*size));
  }
unknown's avatar
unknown committed
813 814 815 816
};

class in_string :public in_vector
{
unknown's avatar
unknown committed
817
  char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
818 819
  String tmp;
public:
820
  in_string(uint elements,qsort2_cmp cmp_func, CHARSET_INFO *cs);
unknown's avatar
unknown committed
821 822 823
  ~in_string();
  void set(uint pos,Item *item);
  byte *get_value(Item *item);
824 825 826 827 828 829 830 831 832 833
  Item* create_item()
  { 
    return new Item_string(collation);
  }
  void value_to_item(uint pos, Item *item)
  {    
    String *str=((String*) base)+pos;
    Item_string *to= (Item_string*)item;
    to->str_value= *str;
  }
unknown's avatar
unknown committed
834 835 836 837
};

class in_longlong :public in_vector
{
838
protected:
unknown's avatar
unknown committed
839 840 841 842 843 844 845 846 847 848
  /*
    Here we declare a temporary variable (tmp) of the same type as the
    elements of this vector. tmp is used in finding if a given value is in 
    the list. 
  */
  struct packed_longlong 
  {
    longlong val;
    longlong unsigned_flag;  // Use longlong, not bool, to preserve alignment
  } tmp;
unknown's avatar
unknown committed
849 850 851 852
public:
  in_longlong(uint elements);
  void set(uint pos,Item *item);
  byte *get_value(Item *item);
853 854 855 856 857 858 859
  
  Item* create_item()
  { 
    /* 
      We're created a signed INT, this may not be correct in 
      general case (see BUG#19342).
    */
unknown's avatar
unknown committed
860
    return new Item_int((longlong)0);
861 862 863
  }
  void value_to_item(uint pos, Item *item)
  {
unknown's avatar
unknown committed
864
    ((Item_int*) item)->value= ((packed_longlong*) base)[pos].val;
unknown's avatar
unknown committed
865
    ((Item_int*) item)->unsigned_flag= (my_bool)
unknown's avatar
unknown committed
866
      ((packed_longlong*) base)[pos].unsigned_flag;
867
  }
unknown's avatar
unknown committed
868 869

  friend int cmp_longlong(void *cmp_arg, packed_longlong *a,packed_longlong *b);
unknown's avatar
unknown committed
870 871
};

872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895

/*
  Class to represent a vector of constant DATE/DATETIME values.
  Values are obtained with help of the get_datetime_value() function.
  If the left item is a constant one then its value is cached in the
  lval_cache variable.
*/
class in_datetime :public in_longlong
{
public:
  THD *thd;
  /* An item used to issue warnings. */
  Item *warn_item;
  /* Cache for the left item. */
  Item *lval_cache;

  in_datetime(Item *warn_item_arg, uint elements)
    :in_longlong(elements), thd(current_thd), warn_item(warn_item_arg),
     lval_cache(0) {};
  void set(uint pos,Item *item);
  byte *get_value(Item *item);
  friend int cmp_longlong(void *cmp_arg, packed_longlong *a,packed_longlong *b);
};

unknown's avatar
unknown committed
896 897 898 899 900 901 902
class in_double :public in_vector
{
  double tmp;
public:
  in_double(uint elements);
  void set(uint pos,Item *item);
  byte *get_value(Item *item);
903 904 905 906 907 908 909 910 911
  Item *create_item()
  { 
    return new Item_float(0.0);
  }
  void value_to_item(uint pos, Item *item)
  {
    ((Item_float*)item)->value= ((double*) base)[pos];
  }

unknown's avatar
unknown committed
912 913
};

unknown's avatar
unknown committed
914 915 916 917 918 919 920
class in_decimal :public in_vector
{
  my_decimal val;
public:
  in_decimal(uint elements);
  void set(uint pos, Item *item);
  byte *get_value(Item *item);
921 922 923 924 925 926 927 928 929 930
  Item *create_item()
  { 
    return new Item_decimal(0, FALSE);
  }
  void value_to_item(uint pos, Item *item)
  {
    my_decimal *dec= ((my_decimal *)base) + pos;
    Item_decimal *item_dec= (Item_decimal*)item;
    item_dec->set_decimal_value(dec);
  }
unknown's avatar
unknown committed
931 932 933
};


unknown's avatar
unknown committed
934 935 936 937 938 939 940
/*
** Classes for easy comparing of non const items
*/

class cmp_item :public Sql_alloc
{
public:
941 942
  CHARSET_INFO *cmp_charset;
  cmp_item() { cmp_charset= &my_charset_bin; }
unknown's avatar
unknown committed
943
  virtual ~cmp_item() {}
unknown's avatar
unknown committed
944 945 946 947
  virtual void store_value(Item *item)= 0;
  virtual int cmp(Item *item)= 0;
  // for optimized IN with row
  virtual int compare(cmp_item *item)= 0;
unknown's avatar
unknown committed
948
  static cmp_item* get_comparator(Item_result type, CHARSET_INFO *cs);
unknown's avatar
unknown committed
949 950 951 952 953
  virtual cmp_item *make_same()= 0;
  virtual void store_value_by_template(cmp_item *tmpl, Item *item)
  {
    store_value(item);
  }
unknown's avatar
unknown committed
954 955
};

unknown's avatar
unknown committed
956 957 958 959 960
class cmp_item_string :public cmp_item 
{
protected:
  String *value_res;
public:
961
  cmp_item_string (CHARSET_INFO *cs) { cmp_charset= cs; }
unknown's avatar
unknown committed
962 963 964
  friend class cmp_item_sort_string;
  friend class cmp_item_sort_string_in_static;
};
unknown's avatar
unknown committed
965

unknown's avatar
unknown committed
966 967 968
class cmp_item_sort_string :public cmp_item_string
{
protected:
unknown's avatar
unknown committed
969
  char value_buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
970
  String value;
unknown's avatar
unknown committed
971
public:
972 973 974
  cmp_item_sort_string(CHARSET_INFO *cs):
    cmp_item_string(cs),
    value(value_buff, sizeof(value_buff), cs) {}
unknown's avatar
unknown committed
975
  void store_value(Item *item)
unknown's avatar
unknown committed
976 977 978
  {
    value_res= item->val_str(&value);
  }
unknown's avatar
unknown committed
979
  int cmp(Item *arg)
unknown's avatar
unknown committed
980
  {
unknown's avatar
unknown committed
981
    char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
982
    String tmp(buff, sizeof(buff), cmp_charset), *res;
983 984 985
    res= arg->val_str(&tmp);
    return (value_res ? (res ? sortcmp(value_res, res, cmp_charset) : 1) :
            (res ? -1 : 0));
unknown's avatar
unknown committed
986
  }
987
  int compare(cmp_item *ci)
unknown's avatar
unknown committed
988
  {
989 990
    cmp_item_string *l_cmp= (cmp_item_string *) ci;
    return sortcmp(value_res, l_cmp->value_res, cmp_charset);
unknown's avatar
unknown committed
991 992
  } 
  cmp_item *make_same();
unknown's avatar
unknown committed
993 994 995 996 997 998
};

class cmp_item_int :public cmp_item
{
  longlong value;
public:
999
  cmp_item_int() {}                           /* Remove gcc warning */
unknown's avatar
unknown committed
1000
  void store_value(Item *item)
unknown's avatar
unknown committed
1001 1002 1003
  {
    value= item->val_int();
  }
unknown's avatar
unknown committed
1004
  int cmp(Item *arg)
unknown's avatar
unknown committed
1005 1006 1007
  {
    return value != arg->val_int();
  }
1008
  int compare(cmp_item *ci)
unknown's avatar
unknown committed
1009
  {
1010 1011
    cmp_item_int *l_cmp= (cmp_item_int *)ci;
    return (value < l_cmp->value) ? -1 : ((value == l_cmp->value) ? 0 : 1);
unknown's avatar
unknown committed
1012 1013
  }
  cmp_item *make_same();
unknown's avatar
unknown committed
1014 1015
};

1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
/*
  Compare items in the DATETIME context.
  Values are obtained with help of the get_datetime_value() function.
  If the left item is a constant one then its value is cached in the
  lval_cache variable.
*/
class cmp_item_datetime :public cmp_item
{
  ulonglong value;
public:
  THD *thd;
  /* Item used for issuing warnings. */
  Item *warn_item;
  /* Cache for the left item. */
  Item *lval_cache;

  cmp_item_datetime(Item *warn_item_arg)
    :thd(current_thd), warn_item(warn_item_arg), lval_cache(0) {}
  void store_value(Item *item);
  int cmp(Item *arg);
  int compare(cmp_item *ci);
  cmp_item *make_same();
};

unknown's avatar
unknown committed
1040 1041 1042 1043
class cmp_item_real :public cmp_item
{
  double value;
public:
1044
  cmp_item_real() {}                          /* Remove gcc warning */
unknown's avatar
unknown committed
1045
  void store_value(Item *item)
unknown's avatar
unknown committed
1046
  {
1047
    value= item->val_real();
unknown's avatar
unknown committed
1048
  }
unknown's avatar
unknown committed
1049
  int cmp(Item *arg)
unknown's avatar
unknown committed
1050
  {
1051
    return value != arg->val_real();
unknown's avatar
unknown committed
1052
  }
1053
  int compare(cmp_item *ci)
unknown's avatar
unknown committed
1054
  {
1055 1056
    cmp_item_real *l_cmp= (cmp_item_real *) ci;
    return (value < l_cmp->value)? -1 : ((value == l_cmp->value) ? 0 : 1);
unknown's avatar
unknown committed
1057 1058
  }
  cmp_item *make_same();
unknown's avatar
unknown committed
1059 1060
};

unknown's avatar
unknown committed
1061 1062 1063 1064 1065

class cmp_item_decimal :public cmp_item
{
  my_decimal value;
public:
1066
  cmp_item_decimal() {}                       /* Remove gcc warning */
unknown's avatar
unknown committed
1067 1068 1069 1070 1071 1072 1073
  void store_value(Item *item);
  int cmp(Item *arg);
  int compare(cmp_item *c);
  cmp_item *make_same();
};


unknown's avatar
unknown committed
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
/* 
   cmp_item for optimized IN with row (right part string, which never
   be changed)
*/

class cmp_item_sort_string_in_static :public cmp_item_string
{
 protected:
  String value;
public:
1084 1085
  cmp_item_sort_string_in_static(CHARSET_INFO *cs):
    cmp_item_string(cs) {}
unknown's avatar
unknown committed
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095
  void store_value(Item *item)
  {
    value_res= item->val_str(&value);
  }
  int cmp(Item *item)
  {
    // Should never be called
    DBUG_ASSERT(0);
    return 1;
  }
1096
  int compare(cmp_item *ci)
unknown's avatar
unknown committed
1097
  {
1098 1099
    cmp_item_string *l_cmp= (cmp_item_string *) ci;
    return sortcmp(value_res, l_cmp->value_res, cmp_charset);
unknown's avatar
unknown committed
1100
  }
1101
  cmp_item *make_same()
unknown's avatar
unknown committed
1102
  {
1103
    return new cmp_item_sort_string_in_static(cmp_charset);
unknown's avatar
unknown committed
1104
  }
1105
};
unknown's avatar
unknown committed
1106

unknown's avatar
unknown committed
1107
class Item_func_in :public Item_func_opt_neg
unknown's avatar
unknown committed
1108
{
1109
public:
1110
  Item_result cmp_type;
1111 1112 1113 1114
  /* 
    an array of values when the right hand arguments of IN
    are all SQL constant and there are no nulls 
  */
unknown's avatar
unknown committed
1115 1116
  in_vector *array;
  cmp_item *in_item;
1117
  bool have_null;
1118
  DTCollation cmp_collation;
1119

1120
  Item_func_in(List<Item> &list)
unknown's avatar
unknown committed
1121
    :Item_func_opt_neg(list), array(0), in_item(0), have_null(0)
1122
  {
1123
    allowed_arg_cols= 0;  // Fetch this value from first argument
1124
  }
unknown's avatar
unknown committed
1125
  longlong val_int();
1126
  bool fix_fields(THD *, Item **);
unknown's avatar
unknown committed
1127
  void fix_length_and_dec();
unknown's avatar
unknown committed
1128
  uint decimal_precision() const { return 1; }
1129 1130
  void cleanup()
  {
unknown's avatar
unknown committed
1131
    DBUG_ENTER("Item_func_in::cleanup");
1132
    Item_int_func::cleanup();
1133 1134 1135 1136
    delete array;
    delete in_item;
    array= 0;
    in_item= 0;
unknown's avatar
unknown committed
1137
    DBUG_VOID_RETURN;
1138
  }
unknown's avatar
unknown committed
1139
  optimize_type select_optimize() const
1140
    { return OPTIMIZE_KEY; }
unknown's avatar
unknown committed
1141 1142 1143
  void print(String *str);
  enum Functype functype() const { return IN_FUNC; }
  const char *func_name() const { return " IN "; }
unknown's avatar
unknown committed
1144
  bool nulls_in_row();
unknown's avatar
unknown committed
1145
  bool is_bool_func() { return 1; }
1146
  CHARSET_INFO *compare_collation() { return cmp_collation.collation; }
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
};

class cmp_item_row :public cmp_item
{
  cmp_item **comparators;
  uint n;
public:
  cmp_item_row(): comparators(0), n(0) {}
  ~cmp_item_row();
  void store_value(Item *item);
  inline void alloc_comparators();
  int cmp(Item *arg);
  int compare(cmp_item *arg);
  cmp_item *make_same();
  void store_value_by_template(cmp_item *tmpl, Item *);
  friend void Item_func_in::fix_length_and_dec();
};


class in_row :public in_vector
{
  cmp_item_row tmp;
public:
  in_row(uint elements, Item *);
  ~in_row();
  void set(uint pos,Item *item);
  byte *get_value(Item *item);
  friend void Item_func_in::fix_length_and_dec();
unknown's avatar
unknown committed
1175 1176 1177 1178 1179 1180
};

/* Functions used by where clause */

class Item_func_isnull :public Item_bool_func
{
1181
protected:
unknown's avatar
unknown committed
1182
  longlong cached_value;
unknown's avatar
unknown committed
1183 1184 1185 1186 1187 1188 1189
public:
  Item_func_isnull(Item *a) :Item_bool_func(a) {}
  longlong val_int();
  enum Functype functype() const { return ISNULL_FUNC; }
  void fix_length_and_dec()
  {
    decimals=0; max_length=1; maybe_null=0;
1190
    update_used_tables();
unknown's avatar
unknown committed
1191 1192 1193
  }
  const char *func_name() const { return "isnull"; }
  /* Optimize case of not_null_column IS NULL */
1194
  virtual void update_used_tables()
unknown's avatar
unknown committed
1195 1196 1197
  {
    if (!args[0]->maybe_null)
    {
1198
      used_tables_cache= 0;			/* is always false */
1199
      const_item_cache= 1;
1200
      cached_value= (longlong) 0;
unknown's avatar
unknown committed
1201
    }
1202
    else
unknown's avatar
unknown committed
1203
    {
1204
      args[0]->update_used_tables();
unknown's avatar
unknown committed
1205 1206
      if ((const_item_cache= !(used_tables_cache= args[0]->used_tables())) &&
          !with_subselect)
1207 1208
      {
	/* Remember if the value is always NULL or never NULL */
1209
	cached_value= (longlong) args[0]->is_null();
1210
      }
unknown's avatar
unknown committed
1211
    }
unknown's avatar
unknown committed
1212
  }
1213
  table_map not_null_tables() const { return 0; }
unknown's avatar
unknown committed
1214
  optimize_type select_optimize() const { return OPTIMIZE_NULL; }
1215
  Item *neg_transformer(THD *thd);
1216
  CHARSET_INFO *compare_collation() { return args[0]->collation.collation; }
unknown's avatar
unknown committed
1217 1218
};

1219 1220 1221
/* Functions used by HAVING for rewriting IN subquery */

class Item_in_subselect;
1222 1223 1224 1225 1226

/* 
  This is like IS NOT NULL but it also remembers if it ever has
  encountered a NULL.
*/
1227 1228 1229 1230 1231 1232 1233
class Item_is_not_null_test :public Item_func_isnull
{
  Item_in_subselect* owner;
public:
  Item_is_not_null_test(Item_in_subselect* ow, Item *a)
    :Item_func_isnull(a), owner(ow)
  {}
1234
  enum Functype functype() const { return ISNOTNULLTEST_FUNC; }
1235
  longlong val_int();
1236
  const char *func_name() const { return "<is_not_null_test>"; }
1237
  void update_used_tables();
1238 1239 1240 1241 1242
  /*
    we add RAND_TABLE_BIT to prevent moving this item from HAVING to WHERE
  */
  table_map used_tables() const
    { return used_tables_cache | RAND_TABLE_BIT; }
1243 1244 1245
};


unknown's avatar
unknown committed
1246 1247
class Item_func_isnotnull :public Item_bool_func
{
1248
  bool abort_on_null;
unknown's avatar
unknown committed
1249
public:
1250
  Item_func_isnotnull(Item *a) :Item_bool_func(a), abort_on_null(0) {}
unknown's avatar
unknown committed
1251 1252
  longlong val_int();
  enum Functype functype() const { return ISNOTNULL_FUNC; }
unknown's avatar
unknown committed
1253 1254 1255 1256
  void fix_length_and_dec()
  {
    decimals=0; max_length=1; maybe_null=0;
  }
unknown's avatar
unknown committed
1257 1258
  const char *func_name() const { return "isnotnull"; }
  optimize_type select_optimize() const { return OPTIMIZE_NULL; }
1259 1260
  table_map not_null_tables() const
  { return abort_on_null ? not_null_tables_cache : 0; }
1261
  Item *neg_transformer(THD *thd);
1262
  void print(String *str);
1263
  CHARSET_INFO *compare_collation() { return args[0]->collation.collation; }
1264
  void top_level_item() { abort_on_null=1; }
unknown's avatar
unknown committed
1265 1266
};

1267

unknown's avatar
unknown committed
1268 1269
class Item_func_like :public Item_bool_func2
{
1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
  // Turbo Boyer-Moore data
  bool        canDoTurboBM;	// pattern is '%abcd%' case
  const char* pattern;
  int         pattern_len;

  // TurboBM buffers, *this is owner
  int* bmGs; //   good suffix shift table, size is pattern_len + 1
  int* bmBc; // bad character shift table, size is alphabet_size

  void turboBM_compute_suffixes(int* suff);
  void turboBM_compute_good_suffix_shifts(int* suff);
  void turboBM_compute_bad_character_shifts();
  bool turboBM_matches(const char* text, int text_len) const;
  enum { alphabet_size = 256 };

1285
  Item *escape_item;
1286 1287
  
  bool escape_used_in_parsing;
1288

unknown's avatar
unknown committed
1289
public:
unknown's avatar
unknown committed
1290
  int escape;
1291

1292
  Item_func_like(Item *a,Item *b, Item *escape_arg, bool escape_used)
unknown's avatar
unknown committed
1293
    :Item_bool_func2(a,b), canDoTurboBM(FALSE), pattern(0), pattern_len(0), 
1294 1295
     bmGs(0), bmBc(0), escape_item(escape_arg),
     escape_used_in_parsing(escape_used) {}
unknown's avatar
unknown committed
1296 1297 1298 1299 1300
  longlong val_int();
  enum Functype functype() const { return LIKE_FUNC; }
  optimize_type select_optimize() const;
  cond_result eq_cmp_result() const { return COND_TRUE; }
  const char *func_name() const { return "like"; }
1301
  bool fix_fields(THD *thd, Item **ref);
1302
  void cleanup();
unknown's avatar
unknown committed
1303 1304 1305 1306
};

#ifdef USE_REGEX

unknown's avatar
unknown committed
1307
#include "my_regex.h"
unknown's avatar
unknown committed
1308 1309 1310

class Item_func_regex :public Item_bool_func
{
unknown's avatar
unknown committed
1311
  my_regex_t preg;
unknown's avatar
unknown committed
1312 1313 1314
  bool regex_compiled;
  bool regex_is_const;
  String prev_regexp;
1315
  DTCollation cmp_collation;
1316 1317 1318 1319
  CHARSET_INFO *regex_lib_charset;
  int regex_lib_flags;
  String conv;
  bool regcomp(bool send_error);
unknown's avatar
unknown committed
1320 1321 1322
public:
  Item_func_regex(Item *a,Item *b) :Item_bool_func(a,b),
    regex_compiled(0),regex_is_const(0) {}
1323
  void cleanup();
unknown's avatar
unknown committed
1324
  longlong val_int();
1325
  bool fix_fields(THD *thd, Item **ref);
1326
  const char *func_name() const { return "regexp"; }
1327
  void print(String *str) { print_op(str); }
1328
  CHARSET_INFO *compare_collation() { return cmp_collation.collation; }
unknown's avatar
unknown committed
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338
};

#else

class Item_func_regex :public Item_bool_func
{
public:
  Item_func_regex(Item *a,Item *b) :Item_bool_func(a,b) {}
  longlong val_int() { return 0;}
  const char *func_name() const { return "regex"; }
1339
  void print(String *str) { print_op(str); }
unknown's avatar
unknown committed
1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
};

#endif /* USE_REGEX */


typedef class Item COND;

class Item_cond :public Item_bool_func
{
protected:
  List<Item> list;
1351
  bool abort_on_null;
1352 1353
  table_map and_tables_cache;

unknown's avatar
unknown committed
1354
public:
1355
  /* Item_cond() is only used to create top level items */
1356 1357
  Item_cond(): Item_bool_func(), abort_on_null(1)
  { const_item_cache=0; }
1358
  Item_cond(Item *i1,Item *i2)
1359 1360 1361 1362 1363
    :Item_bool_func(), abort_on_null(0)
  {
    list.push_back(i1);
    list.push_back(i2);
  }
1364
  Item_cond(THD *thd, Item_cond *item);
1365 1366
  Item_cond(List<Item> &nlist)
    :Item_bool_func(), list(nlist), abort_on_null(0) {}
unknown's avatar
unknown committed
1367
  bool add(Item *item) { return list.push_back(item); }
1368
  bool add_at_head(Item *item) { return list.push_front(item); }
unknown's avatar
unknown committed
1369
  void add_at_head(List<Item> *nlist) { list.prepand(nlist); }
1370
  bool fix_fields(THD *, Item **ref);
unknown's avatar
unknown committed
1371 1372 1373 1374 1375 1376

  enum Type type() const { return COND_ITEM; }
  List<Item>* argument_list() { return &list; }
  table_map used_tables() const;
  void update_used_tables();
  void print(String *str);
1377
  void split_sum_func(THD *thd, Item **ref_pointer_array, List<Item> &fields);
1378
  friend int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
1379
                         COND **conds);
1380
  void top_level_item() { abort_on_null=1; }
1381
  void copy_andor_arguments(THD *thd, Item_cond *item);
unknown's avatar
unknown committed
1382
  bool walk(Item_processor processor, byte *arg);
unknown's avatar
unknown committed
1383
  Item *transform(Item_transformer transformer, byte *arg);
1384
  void traverse_cond(Cond_traverser, void *arg, traverse_order order);
1385
  void neg_arguments(THD *thd);
1386 1387 1388
  bool subst_argument_checker(byte **arg) { return TRUE; }
  Item *compile(Item_analyzer analyzer, byte **arg_p,
                Item_transformer transformer, byte *arg_t);
unknown's avatar
unknown committed
1389 1390 1391
};


unknown's avatar
unknown committed
1392
/*
unknown's avatar
unknown committed
1393
  The class Item_equal is used to represent conjunctions of equality
unknown's avatar
unknown committed
1394 1395
  predicates of the form field1 = field2, and field=const in where
  conditions and on expressions.
1396 1397

  All equality predicates of the form field1=field2 contained in a
unknown's avatar
unknown committed
1398 1399
  conjunction are substituted for a sequence of items of this class.
  An item of this class Item_equal(f1,f2,...fk) represents a
unknown's avatar
unknown committed
1400 1401
  multiple equality f1=f2=...=fk.

unknown's avatar
unknown committed
1402
  If a conjunction contains predicates f1=f2 and f2=f3, a new item of
unknown's avatar
unknown committed
1403 1404
  this class is created Item_equal(f1,f2,f3) representing the multiple
  equality f1=f2=f3 that substitutes the above equality predicates in
unknown's avatar
unknown committed
1405 1406
  the conjunction.
  A conjunction of the predicates f2=f1 and f3=f1 and f3=f2 will be
unknown's avatar
unknown committed
1407 1408
  substituted for the item representing the same multiple equality
  f1=f2=f3.
unknown's avatar
unknown committed
1409
  An item Item_equal(f1,f2) can appear instead of a conjunction of 
unknown's avatar
unknown committed
1410 1411
  f2=f1 and f1=f2, or instead of just the predicate f1=f2.

unknown's avatar
unknown committed
1412
  An item of the class Item_equal inherits equalities from outer 
unknown's avatar
unknown committed
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422
  conjunctive levels.

  Suppose we have a where condition of the following form:
  WHERE f1=f2 AND f3=f4 AND f3=f5 AND ... AND (...OR (f1=f3 AND ...)).
  In this case:
    f1=f2 will be substituted for Item_equal(f1,f2);
    f3=f4 and f3=f5  will be substituted for Item_equal(f3,f4,f5);
    f1=f3 will be substituted for Item_equal(f1,f2,f3,f4,f5);

  An object of the class Item_equal can contain an optional constant
unknown's avatar
unknown committed
1423
  item c. Then it represents a multiple equality of the form 
unknown's avatar
unknown committed
1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440
  c=f1=...=fk.

  Objects of the class Item_equal are used for the following:

  1. An object Item_equal(t1.f1,...,tk.fk) allows us to consider any
  pair of tables ti and tj as joined by an equi-condition.
  Thus it provide us with additional access paths from table to table.

  2. An object Item_equal(t1.f1,...,tk.fk) is applied to deduce new
  SARGable predicates:
    f1=...=fk AND P(fi) => f1=...=fk AND P(fi) AND P(fj).
  It also can give us additional index scans and can allow us to
  improve selectivity estimates.

  3. An object Item_equal(t1.f1,...,tk.fk) is used to optimize the 
  selected execution plan for the query: if table ti is accessed 
  before the table tj then in any predicate P in the where condition
unknown's avatar
unknown committed
1441
  the occurrence of tj.fj is substituted for ti.fi. This can allow
unknown's avatar
unknown committed
1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453
  an evaluation of the predicate at an earlier step.

  When feature 1 is supported they say that join transitive closure 
  is employed.
  When feature 2 is supported they say that search argument transitive
  closure is employed.
  Both features are usually supported by preprocessing original query and
  adding additional predicates.
  We do not just add predicates, we rather dynamically replace some
  predicates that can not be used to access tables in the investigated
  plan for those, obtained by substitution of some fields for equal fields,
  that can be used.     
1454 1455 1456 1457 1458 1459

  Prepared Statements/Stored Procedures note: instances of class
  Item_equal are created only at the time a PS/SP is executed and
  are deleted in the end of execution. All changes made to these
  objects need not be registered in the list of changes of the parse
  tree and do not harm PS/SP re-execution.
1460 1461 1462 1463 1464

  Item equal objects are employed only at the optimize phase. Usually they are
  not supposed to be evaluated.  Yet in some cases we call the method val_int()
  for them. We have to take care of restricting the predicate such an
  object represents f1=f2= ...=fn to the projection of known fields fi1=...=fik.
unknown's avatar
unknown committed
1465 1466
*/

1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482
class Item_equal: public Item_bool_func
{
  List<Item_field> fields; /* list of equal field items                    */
  Item *const_item;        /* optional constant item equal to fields items */
  cmp_item *eval_item;
  bool cond_false;
public:
  inline Item_equal()
    : Item_bool_func(), const_item(0), eval_item(0), cond_false(0)
  { const_item_cache=0 ;}
  Item_equal(Item_field *f1, Item_field *f2);
  Item_equal(Item *c, Item_field *f);
  Item_equal(Item_equal *item_equal);
  inline Item* get_const() { return const_item; }
  void add(Item *c);
  void add(Item_field *f);
unknown's avatar
unknown committed
1483
  uint members();
1484 1485 1486
  bool contains(Field *field);
  Item_field* get_first() { return fields.head(); }
  void merge(Item_equal *item);
1487
  void update_const();
1488 1489 1490 1491
  enum Functype functype() const { return MULT_EQUAL_FUNC; }
  longlong val_int(); 
  const char *func_name() const { return "multiple equal"; }
  optimize_type select_optimize() const { return OPTIMIZE_EQUAL; }
unknown's avatar
unknown committed
1492
  void sort(Item_field_cmpfunc cmp, void *arg);
1493 1494
  friend class Item_equal_iterator;
  void fix_length_and_dec();
1495
  bool fix_fields(THD *thd, Item **ref);
1496 1497
  void update_used_tables();
  bool walk(Item_processor processor, byte *arg);
unknown's avatar
unknown committed
1498
  Item *transform(Item_transformer transformer, byte *arg);
1499
  void print(String *str);
unknown's avatar
unknown committed
1500 1501
  CHARSET_INFO *compare_collation() 
  { return fields.head()->collation.collation; }
1502 1503
}; 

unknown's avatar
unknown committed
1504
class COND_EQUAL: public Sql_alloc
1505 1506
{
public:
unknown's avatar
unknown committed
1507 1508 1509 1510 1511 1512 1513 1514 1515
  uint max_members;               /* max number of members the current level
                                     list and all lower level lists */ 
  COND_EQUAL *upper_levels;       /* multiple equalities of upper and levels */
  List<Item_equal> current_level; /* list of multiple equalities of 
                                     the current and level           */
  COND_EQUAL()
  { 
    upper_levels= 0;
  }
1516 1517 1518
};


unknown's avatar
unknown committed
1519
class Item_equal_iterator : public List_iterator_fast<Item_field>
1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535
{
public:
  inline Item_equal_iterator(Item_equal &item_equal) 
    :List_iterator_fast<Item_field> (item_equal.fields)
  {}
  inline Item_field* operator++(int)
  { 
    Item_field *item= (*(List_iterator_fast<Item_field> *) this)++;
    return  item;
  }
  inline void rewind(void) 
  { 
    List_iterator_fast<Item_field>::rewind();
  }
};

unknown's avatar
unknown committed
1536 1537 1538
class Item_cond_and :public Item_cond
{
public:
unknown's avatar
unknown committed
1539 1540 1541
  COND_EQUAL cond_equal;  /* contains list of Item_equal objects for 
                             the current and level and reference
                             to multiple equalities of upper and levels */  
unknown's avatar
unknown committed
1542 1543
  Item_cond_and() :Item_cond() {}
  Item_cond_and(Item *i1,Item *i2) :Item_cond(i1,i2) {}
1544
  Item_cond_and(THD *thd, Item_cond_and *item) :Item_cond(thd, item) {}
1545
  Item_cond_and(List<Item> &list_arg): Item_cond(list_arg) {}
unknown's avatar
unknown committed
1546 1547 1548
  enum Functype functype() const { return COND_AND_FUNC; }
  longlong val_int();
  const char *func_name() const { return "and"; }
1549 1550
  table_map not_null_tables() const
  { return abort_on_null ? not_null_tables_cache: and_tables_cache; }
1551 1552 1553
  Item* copy_andor_structure(THD *thd)
  {
    Item_cond_and *item;
unknown's avatar
merge  
unknown committed
1554
    if ((item= new Item_cond_and(thd, this)))
1555 1556 1557
       item->copy_andor_arguments(thd, this);
    return item;
  }
1558
  Item *neg_transformer(THD *thd);
unknown's avatar
unknown committed
1559 1560
};

1561 1562 1563 1564 1565 1566 1567 1568 1569
inline bool is_cond_and(Item *item)
{
  if (item->type() != Item::COND_ITEM)
    return FALSE;

  Item_cond *cond_item= (Item_cond*) item;
  return (cond_item->functype() == Item_func::COND_AND_FUNC);
}

unknown's avatar
unknown committed
1570 1571 1572 1573 1574
class Item_cond_or :public Item_cond
{
public:
  Item_cond_or() :Item_cond() {}
  Item_cond_or(Item *i1,Item *i2) :Item_cond(i1,i2) {}
1575
  Item_cond_or(THD *thd, Item_cond_or *item) :Item_cond(thd, item) {}
1576
  Item_cond_or(List<Item> &list_arg): Item_cond(list_arg) {}
unknown's avatar
unknown committed
1577 1578 1579
  enum Functype functype() const { return COND_OR_FUNC; }
  longlong val_int();
  const char *func_name() const { return "or"; }
1580
  table_map not_null_tables() const { return and_tables_cache; }
1581 1582 1583
  Item* copy_andor_structure(THD *thd)
  {
    Item_cond_or *item;
unknown's avatar
merge  
unknown committed
1584
    if ((item= new Item_cond_or(thd, this)))
1585 1586 1587
      item->copy_andor_arguments(thd, this);
    return item;
  }
1588
  Item *neg_transformer(THD *thd);
unknown's avatar
unknown committed
1589 1590
};

1591 1592 1593 1594 1595 1596 1597 1598
inline bool is_cond_or(Item *item)
{
  if (item->type() != Item::COND_ITEM)
    return FALSE;

  Item_cond *cond_item= (Item_cond*) item;
  return (cond_item->functype() == Item_func::COND_OR_FUNC);
}
unknown's avatar
unknown committed
1599

1600
/*
unknown's avatar
unknown committed
1601
  XOR is Item_cond, not an Item_int_func because we could like to
1602 1603
  optimize (a XOR b) later on. It's low prio, though
*/
unknown's avatar
unknown committed
1604

unknown's avatar
unknown committed
1605 1606 1607 1608 1609 1610
class Item_cond_xor :public Item_cond
{
public:
  Item_cond_xor() :Item_cond() {}
  Item_cond_xor(Item *i1,Item *i2) :Item_cond(i1,i2) {}
  enum Functype functype() const { return COND_XOR_FUNC; }
1611 1612
  /* TODO: remove the next line when implementing XOR optimization */
  enum Type type() const { return FUNC_ITEM; }
unknown's avatar
unknown committed
1613 1614
  longlong val_int();
  const char *func_name() const { return "xor"; }
1615
  void top_level_item() {}
unknown's avatar
unknown committed
1616 1617 1618
};


unknown's avatar
unknown committed
1619
/* Some useful inline functions */
unknown's avatar
unknown committed
1620

unknown's avatar
unknown committed
1621
inline Item *and_conds(Item *a, Item *b)
unknown's avatar
unknown committed
1622 1623 1624
{
  if (!b) return a;
  if (!a) return b;
unknown's avatar
unknown committed
1625
  return new Item_cond_and(a, b);
unknown's avatar
unknown committed
1626
}
unknown's avatar
unknown committed
1627

unknown's avatar
unknown committed
1628
Item *and_expressions(Item *a, Item *b, Item **org_item);