item_cmpfunc.h 51.9 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
  {
57
    return set_compare_func(owner_arg, item_cmp_type((*a)->result_type(),
unknown's avatar
unknown committed
58
                                                     (*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

/**
  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();
126
  virtual void print(String *str, enum_query_type query_type);
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

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
  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; }
341 342 343 344 345 346

  virtual inline void print(String *str, enum_query_type query_type)
  {
    Item_func::print_op(str, query_type);
  }

unknown's avatar
unknown committed
347
  bool is_null() { return test(args[0]->is_null() || args[1]->is_null()); }
unknown's avatar
unknown committed
348
  bool is_bool_func() { return 1; }
349
  CHARSET_INFO *compare_collation() { return cmp.cmp_collation.collation; }
unknown's avatar
unknown committed
350
  uint decimal_precision() const { return 1; }
351
  void top_level_item() { abort_on_null= TRUE; }
unknown's avatar
unknown committed
352

353
  friend class  Arg_comparator;
unknown's avatar
unknown committed
354 355
};

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

class Item_func_not :public Item_bool_func
{
public:
  Item_func_not(Item *a) :Item_bool_func(a) {}
  longlong val_int();
373
  enum Functype functype() const { return NOT_FUNC; }
unknown's avatar
unknown committed
374
  const char *func_name() const { return "not"; }
375
  Item *neg_transformer(THD *thd);
376
  virtual void print(String *str, enum_query_type query_type);
unknown's avatar
unknown committed
377 378
};

379
class Item_maxmin_subselect;
380 381

/*
382 383
  trigcond<param>(arg) ::= param? arg : TRUE

384 385
  The class Item_func_trig_cond is used for guarded predicates 
  which are employed only for internal purposes.
386
  A guarded predicate is an object consisting of an a regular or
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
  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. 
404 405 406 407
 
  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
408 409 410 411 412 413 414 415 416 417
*/

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"; };
418
  bool const_item() const { return FALSE; }
419
  bool *get_trig_var() { return trig_var; }
420 421
};

422 423
class Item_func_not_all :public Item_func_not
{
unknown's avatar
unknown committed
424
  /* allow to check presence of values in max/min optimization */
425 426 427
  Item_sum_hybrid *test_sum_item;
  Item_maxmin_subselect *test_sub_item;

428 429
  bool abort_on_null;
public:
unknown's avatar
unknown committed
430 431
  bool show;

432 433 434 435
  Item_func_not_all(Item *a)
    :Item_func_not(a), test_sum_item(0), test_sub_item(0), abort_on_null(0),
     show(0)
    {}
436 437 438
  virtual void top_level_item() { abort_on_null= 1; }
  bool top_level() { return abort_on_null; }
  longlong val_int();
439
  enum Functype functype() const { return NOT_ALL_FUNC; }
unknown's avatar
unknown committed
440
  const char *func_name() const { return "<not>"; }
441
  virtual void print(String *str, enum_query_type query_type);
442 443 444
  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();
445
  Item *neg_transformer(THD *thd);
446 447
};

448 449 450 451 452 453 454 455

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>"; }
456
  Item *neg_transformer(THD *thd);
457 458 459
};


unknown's avatar
unknown committed
460
class Item_func_eq :public Item_bool_rowready_func2
unknown's avatar
unknown committed
461 462
{
public:
463
  Item_func_eq(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {}
unknown's avatar
unknown committed
464 465 466 467 468
  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 "="; }
469
  Item *negated_item();
unknown's avatar
unknown committed
470 471
};

unknown's avatar
unknown committed
472
class Item_func_equal :public Item_bool_rowready_func2
unknown's avatar
unknown committed
473 474
{
public:
unknown's avatar
unknown committed
475
  Item_func_equal(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {};
unknown's avatar
unknown committed
476
  longlong val_int();
unknown's avatar
unknown committed
477
  void fix_length_and_dec();
478
  table_map not_null_tables() const { return 0; }
unknown's avatar
unknown committed
479 480 481 482
  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 "<=>"; }
483
  Item *neg_transformer(THD *thd) { return 0; }
unknown's avatar
unknown committed
484 485 486
};


unknown's avatar
unknown committed
487
class Item_func_ge :public Item_bool_rowready_func2
unknown's avatar
unknown committed
488 489
{
public:
490
  Item_func_ge(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {};
unknown's avatar
unknown committed
491 492 493 494 495
  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 ">="; }
496
  Item *negated_item();
unknown's avatar
unknown committed
497 498 499
};


unknown's avatar
unknown committed
500
class Item_func_gt :public Item_bool_rowready_func2
unknown's avatar
unknown committed
501 502
{
public:
503
  Item_func_gt(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {};
unknown's avatar
unknown committed
504 505 506 507 508
  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 ">"; }
509
  Item *negated_item();
unknown's avatar
unknown committed
510 511 512
};


unknown's avatar
unknown committed
513
class Item_func_le :public Item_bool_rowready_func2
unknown's avatar
unknown committed
514 515
{
public:
516
  Item_func_le(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {};
unknown's avatar
unknown committed
517 518 519 520 521
  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 "<="; }
522
  Item *negated_item();
unknown's avatar
unknown committed
523 524 525
};


unknown's avatar
unknown committed
526
class Item_func_lt :public Item_bool_rowready_func2
unknown's avatar
unknown committed
527 528
{
public:
529
  Item_func_lt(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {}
unknown's avatar
unknown committed
530 531 532 533 534
  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 "<"; }
535
  Item *negated_item();
unknown's avatar
unknown committed
536 537 538
};


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


unknown's avatar
unknown committed
552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
/*
  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;
  }
579
  bool eq(const Item *item, bool binary_cmp) const;
580
  bool subst_argument_checker(uchar **arg) { return TRUE; }
unknown's avatar
unknown committed
581 582 583 584
};


class Item_func_between :public Item_func_opt_neg
unknown's avatar
unknown committed
585
{
586
  DTCollation cmp_collation;
unknown's avatar
unknown committed
587 588 589
public:
  Item_result cmp_type;
  String value0,value1,value2;
590 591 592 593
  /* 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
594
  Item_func_between(Item *a, Item *b, Item *c)
595
    :Item_func_opt_neg(a, b, c), compare_as_dates(FALSE) {}
unknown's avatar
unknown committed
596 597 598 599
  longlong val_int();
  optimize_type select_optimize() const { return OPTIMIZE_KEY; }
  enum Functype functype() const   { return BETWEEN; }
  const char *func_name() const { return "between"; }
600
  bool fix_fields(THD *, Item **);
unknown's avatar
unknown committed
601
  void fix_length_and_dec();
602
  virtual void print(String *str, enum_query_type query_type);
unknown's avatar
unknown committed
603
  bool is_bool_func() { return 1; }
604
  CHARSET_INFO *compare_collation() { return cmp_collation.collation; }
unknown's avatar
unknown committed
605
  uint decimal_precision() const { return 1; }
unknown's avatar
unknown committed
606 607 608 609 610 611 612 613 614 615
};


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"; }
616 617 618 619 620

  virtual inline void print(String *str, enum_query_type query_type)
  {
    Item_func::print(str, query_type);
  }
unknown's avatar
unknown committed
621 622 623
};


unknown's avatar
unknown committed
624 625 626 627 628 629 630
struct interval_range
{
  Item_result type;
  double dbl;
  my_decimal dec;
};

unknown's avatar
unknown committed
631 632
class Item_func_interval :public Item_int_func
{
633
  Item_row *row;
unknown's avatar
unknown committed
634 635
  my_bool use_decimal_comparison;
  interval_range *intervals;
unknown's avatar
unknown committed
636
public:
637
  Item_func_interval(Item_row *a)
638 639 640 641
    :Item_int_func(a),row(a),intervals(0)
  {
    allowed_arg_cols= 0;    // Fetch this value from first argument
  }
unknown's avatar
unknown committed
642 643 644
  longlong val_int();
  void fix_length_and_dec();
  const char *func_name() const { return "interval"; }
unknown's avatar
unknown committed
645
  uint decimal_precision() const { return 2; }
unknown's avatar
unknown committed
646 647 648
};


unknown's avatar
unknown committed
649
class Item_func_coalesce :public Item_func_numhybrid
unknown's avatar
unknown committed
650
{
unknown's avatar
unknown committed
651
protected:
652
  enum_field_types cached_field_type;
unknown's avatar
unknown committed
653
  Item_func_coalesce(Item *a, Item *b) :Item_func_numhybrid(a, b) {}
unknown's avatar
unknown committed
654
public:
unknown's avatar
unknown committed
655 656 657 658 659
  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
660
  void fix_length_and_dec();
unknown's avatar
unknown committed
661 662
  void find_num_type() {}
  enum Item_result result_type () const { return hybrid_type; }
unknown's avatar
unknown committed
663 664
  const char *func_name() const { return "coalesce"; }
  table_map not_null_tables() const { return 0; }
665
  enum_field_types field_type() const { return cached_field_type; }
unknown's avatar
unknown committed
666 667 668 669 670 671
};


class Item_func_ifnull :public Item_func_coalesce
{
protected:
672
  bool field_type_defined;
unknown's avatar
unknown committed
673
public:
unknown's avatar
unknown committed
674
  Item_func_ifnull(Item *a, Item *b) :Item_func_coalesce(a,b) {}
unknown's avatar
unknown committed
675 676 677 678
  double real_op();
  longlong int_op();
  String *str_op(String *str);
  my_decimal *decimal_op(my_decimal *);
679
  enum_field_types field_type() const;
unknown's avatar
unknown committed
680 681
  void fix_length_and_dec();
  const char *func_name() const { return "ifnull"; }
682
  Field *tmp_table_field(TABLE *table);
unknown's avatar
unknown committed
683
  uint decimal_precision() const;
unknown's avatar
unknown committed
684 685 686 687 688 689
};


class Item_func_if :public Item_func
{
  enum Item_result cached_result_type;
690
  enum_field_types cached_field_type;
unknown's avatar
unknown committed
691
public:
692 693 694
  Item_func_if(Item *a,Item *b,Item *c)
    :Item_func(a,b,c), cached_result_type(INT_RESULT)
  {}
695
  double val_real();
unknown's avatar
unknown committed
696 697
  longlong val_int();
  String *val_str(String *str);
unknown's avatar
unknown committed
698
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
699
  enum Item_result result_type () const { return cached_result_type; }
700
  enum_field_types field_type() const { return cached_field_type; }
701
  bool fix_fields(THD *, Item **);
unknown's avatar
unknown committed
702
  void fix_length_and_dec();
unknown's avatar
unknown committed
703
  uint decimal_precision() const;
unknown's avatar
unknown committed
704 705 706 707 708 709 710 711
  const char *func_name() const { return "if"; }
};


class Item_func_nullif :public Item_bool_func2
{
  enum Item_result cached_result_type;
public:
712 713 714
  Item_func_nullif(Item *a,Item *b)
    :Item_bool_func2(a,b), cached_result_type(INT_RESULT)
  {}
715
  double val_real();
unknown's avatar
unknown committed
716 717
  longlong val_int();
  String *val_str(String *str);
unknown's avatar
unknown committed
718
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
719 720
  enum Item_result result_type () const { return cached_result_type; }
  void fix_length_and_dec();
unknown's avatar
unknown committed
721
  uint decimal_precision() const { return args[0]->decimal_precision(); }
unknown's avatar
unknown committed
722
  const char *func_name() const { return "nullif"; }
723 724 725 726 727 728

  virtual inline void print(String *str, enum_query_type query_type)
  {
    Item_func::print(str, query_type);
  }

729
  table_map not_null_tables() const { return 0; }
730
  bool is_null();
unknown's avatar
unknown committed
731 732 733 734 735
};


/* Functions to handle the optimized IN */

736 737 738

/* A vector of values of some type  */

unknown's avatar
unknown committed
739 740
class in_vector :public Sql_alloc
{
741
public:
unknown's avatar
unknown committed
742 743
  char *base;
  uint size;
744 745
  qsort2_cmp compare;
  CHARSET_INFO *collation;
unknown's avatar
unknown committed
746 747
  uint count;
  uint used_count;
unknown's avatar
unknown committed
748
  in_vector() {}
749 750
  in_vector(uint elements,uint element_length,qsort2_cmp cmp_func, 
  	    CHARSET_INFO *cmp_coll)
unknown's avatar
unknown committed
751
    :base((char*) sql_calloc(elements*element_length)),
752 753
     size(element_length), compare(cmp_func), collation(cmp_coll),
     count(elements), used_count(elements) {}
unknown's avatar
unknown committed
754 755
  virtual ~in_vector() {}
  virtual void set(uint pos,Item *item)=0;
756
  virtual uchar *get_value(Item *item)=0;
unknown's avatar
unknown committed
757
  void sort()
758
  {
759
    my_qsort2(base,used_count,size,compare,collation);
760
  }
unknown's avatar
unknown committed
761
  int find(Item *item);
762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787
  
  /* 
    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));
  }
788
  virtual Item_result result_type()= 0;
unknown's avatar
unknown committed
789 790 791 792
};

class in_string :public in_vector
{
unknown's avatar
unknown committed
793
  char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
794 795
  String tmp;
public:
796
  in_string(uint elements,qsort2_cmp cmp_func, CHARSET_INFO *cs);
unknown's avatar
unknown committed
797 798
  ~in_string();
  void set(uint pos,Item *item);
799
  uchar *get_value(Item *item);
800 801 802 803 804 805 806 807 808 809
  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;
  }
810
  Item_result result_type() { return STRING_RESULT; }
unknown's avatar
unknown committed
811 812 813 814
};

class in_longlong :public in_vector
{
815
protected:
unknown's avatar
unknown committed
816 817 818 819 820 821 822 823 824 825
  /*
    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
826 827 828
public:
  in_longlong(uint elements);
  void set(uint pos,Item *item);
829
  uchar *get_value(Item *item);
830 831 832 833 834 835 836
  
  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
837
    return new Item_int((longlong)0);
838 839 840
  }
  void value_to_item(uint pos, Item *item)
  {
unknown's avatar
unknown committed
841
    ((Item_int*) item)->value= ((packed_longlong*) base)[pos].val;
unknown's avatar
unknown committed
842
    ((Item_int*) item)->unsigned_flag= (my_bool)
unknown's avatar
unknown committed
843
      ((packed_longlong*) base)[pos].unsigned_flag;
844
  }
845
  Item_result result_type() { return INT_RESULT; }
unknown's avatar
unknown committed
846 847

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

850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869

/*
  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);
unknown's avatar
unknown committed
870
  uchar *get_value(Item *item);
871 872 873
  friend int cmp_longlong(void *cmp_arg, packed_longlong *a,packed_longlong *b);
};

874

unknown's avatar
unknown committed
875 876 877 878 879 880
class in_double :public in_vector
{
  double tmp;
public:
  in_double(uint elements);
  void set(uint pos,Item *item);
881
  uchar *get_value(Item *item);
882 883
  Item *create_item()
  { 
884
    return new Item_float(0.0, 0);
885 886 887 888 889
  }
  void value_to_item(uint pos, Item *item)
  {
    ((Item_float*)item)->value= ((double*) base)[pos];
  }
890
  Item_result result_type() { return REAL_RESULT; }
unknown's avatar
unknown committed
891 892
};

893

unknown's avatar
unknown committed
894 895 896 897 898 899
class in_decimal :public in_vector
{
  my_decimal val;
public:
  in_decimal(uint elements);
  void set(uint pos, Item *item);
900
  uchar *get_value(Item *item);
901 902 903 904 905 906 907 908 909 910
  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);
  }
911 912
  Item_result result_type() { return DECIMAL_RESULT; }

unknown's avatar
unknown committed
913 914 915
};


unknown's avatar
unknown committed
916 917 918 919 920 921 922
/*
** Classes for easy comparing of non const items
*/

class cmp_item :public Sql_alloc
{
public:
923 924
  CHARSET_INFO *cmp_charset;
  cmp_item() { cmp_charset= &my_charset_bin; }
unknown's avatar
unknown committed
925
  virtual ~cmp_item() {}
unknown's avatar
unknown committed
926 927 928 929
  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
930
  static cmp_item* get_comparator(Item_result type, CHARSET_INFO *cs);
unknown's avatar
unknown committed
931 932 933 934 935
  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
936 937
};

unknown's avatar
unknown committed
938 939 940 941 942
class cmp_item_string :public cmp_item 
{
protected:
  String *value_res;
public:
943
  cmp_item_string () {}
944
  cmp_item_string (CHARSET_INFO *cs) { cmp_charset= cs; }
945
  void set_charset(CHARSET_INFO *cs) { cmp_charset= cs; }
unknown's avatar
unknown committed
946 947 948
  friend class cmp_item_sort_string;
  friend class cmp_item_sort_string_in_static;
};
unknown's avatar
unknown committed
949

unknown's avatar
unknown committed
950 951 952
class cmp_item_sort_string :public cmp_item_string
{
protected:
unknown's avatar
unknown committed
953
  char value_buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
954
  String value;
unknown's avatar
unknown committed
955
public:
956 957
  cmp_item_sort_string():
    cmp_item_string() {}
958 959 960
  cmp_item_sort_string(CHARSET_INFO *cs):
    cmp_item_string(cs),
    value(value_buff, sizeof(value_buff), cs) {}
unknown's avatar
unknown committed
961
  void store_value(Item *item)
unknown's avatar
unknown committed
962 963 964
  {
    value_res= item->val_str(&value);
  }
unknown's avatar
unknown committed
965
  int cmp(Item *arg)
unknown's avatar
unknown committed
966
  {
unknown's avatar
unknown committed
967
    char buff[STRING_BUFFER_USUAL_SIZE];
unknown's avatar
unknown committed
968
    String tmp(buff, sizeof(buff), cmp_charset), *res;
969 970 971
    res= arg->val_str(&tmp);
    return (value_res ? (res ? sortcmp(value_res, res, cmp_charset) : 1) :
            (res ? -1 : 0));
unknown's avatar
unknown committed
972
  }
973
  int compare(cmp_item *ci)
unknown's avatar
unknown committed
974
  {
975 976
    cmp_item_string *l_cmp= (cmp_item_string *) ci;
    return sortcmp(value_res, l_cmp->value_res, cmp_charset);
unknown's avatar
unknown committed
977 978
  } 
  cmp_item *make_same();
979 980 981 982 983
  void set_charset(CHARSET_INFO *cs)
  {
    cmp_charset= cs;
    value.set_quick(value_buff, sizeof(value_buff), cs);
  }
unknown's avatar
unknown committed
984 985 986 987 988 989
};

class cmp_item_int :public cmp_item
{
  longlong value;
public:
990
  cmp_item_int() {}                           /* Remove gcc warning */
unknown's avatar
unknown committed
991
  void store_value(Item *item)
unknown's avatar
unknown committed
992 993 994
  {
    value= item->val_int();
  }
unknown's avatar
unknown committed
995
  int cmp(Item *arg)
unknown's avatar
unknown committed
996 997 998
  {
    return value != arg->val_int();
  }
999
  int compare(cmp_item *ci)
unknown's avatar
unknown committed
1000
  {
1001 1002
    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
1003 1004
  }
  cmp_item *make_same();
unknown's avatar
unknown committed
1005 1006
};

1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
/*
  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
1031 1032 1033 1034
class cmp_item_real :public cmp_item
{
  double value;
public:
1035
  cmp_item_real() {}                          /* Remove gcc warning */
unknown's avatar
unknown committed
1036
  void store_value(Item *item)
unknown's avatar
unknown committed
1037
  {
1038
    value= item->val_real();
unknown's avatar
unknown committed
1039
  }
unknown's avatar
unknown committed
1040
  int cmp(Item *arg)
unknown's avatar
unknown committed
1041
  {
1042
    return value != arg->val_real();
unknown's avatar
unknown committed
1043
  }
1044
  int compare(cmp_item *ci)
unknown's avatar
unknown committed
1045
  {
1046 1047
    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
1048 1049
  }
  cmp_item *make_same();
unknown's avatar
unknown committed
1050 1051
};

unknown's avatar
unknown committed
1052 1053 1054 1055 1056

class cmp_item_decimal :public cmp_item
{
  my_decimal value;
public:
1057
  cmp_item_decimal() {}                       /* Remove gcc warning */
unknown's avatar
unknown committed
1058 1059 1060 1061 1062 1063 1064
  void store_value(Item *item);
  int cmp(Item *arg);
  int compare(cmp_item *c);
  cmp_item *make_same();
};


unknown's avatar
unknown committed
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
/* 
   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:
1075 1076
  cmp_item_sort_string_in_static(CHARSET_INFO *cs):
    cmp_item_string(cs) {}
unknown's avatar
unknown committed
1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
  void store_value(Item *item)
  {
    value_res= item->val_str(&value);
  }
  int cmp(Item *item)
  {
    // Should never be called
    DBUG_ASSERT(0);
    return 1;
  }
1087
  int compare(cmp_item *ci)
unknown's avatar
unknown committed
1088
  {
1089 1090
    cmp_item_string *l_cmp= (cmp_item_string *) ci;
    return sortcmp(value_res, l_cmp->value_res, cmp_charset);
unknown's avatar
unknown committed
1091
  }
1092
  cmp_item *make_same()
unknown's avatar
unknown committed
1093
  {
1094
    return new cmp_item_sort_string_in_static(cmp_charset);
unknown's avatar
unknown committed
1095
  }
1096
};
unknown's avatar
unknown committed
1097

1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124

/*
  The class Item_func_case is the CASE ... WHEN ... THEN ... END function
  implementation.

  When there is no expression between CASE and the first WHEN 
  (the CASE expression) then this function simple checks all WHEN expressions
  one after another. When some WHEN expression evaluated to TRUE then the
  value of the corresponding THEN expression is returned.

  When the CASE expression is specified then it is compared to each WHEN
  expression individually. When an equal WHEN expression is found
  corresponding THEN expression is returned.
  In order to do correct comparisons several comparators are used. One for
  each result type. Different result types that are used in particular
  CASE ... END expression are collected in the fix_length_and_dec() member
  function and only comparators for there result types are used.
*/

class Item_func_case :public Item_func
{
  int first_expr_num, else_expr_num;
  enum Item_result cached_result_type, left_result_type;
  String tmp_value;
  uint ncases;
  Item_result cmp_type;
  DTCollation cmp_collation;
1125
  enum_field_types cached_field_type;
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
  cmp_item *cmp_items[5]; /* For all result types */
  cmp_item *case_item;
public:
  Item_func_case(List<Item> &list, Item *first_expr_arg, Item *else_expr_arg)
    :Item_func(), first_expr_num(-1), else_expr_num(-1),
    cached_result_type(INT_RESULT), left_result_type(INT_RESULT), case_item(0)
  {
    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);
    bzero(&cmp_items, sizeof(cmp_items));
  }
  double val_real();
  longlong val_int();
  String *val_str(String *);
  my_decimal *val_decimal(my_decimal *);
  bool fix_fields(THD *thd, Item **ref);
  void fix_length_and_dec();
  uint decimal_precision() const;
  table_map not_null_tables() const { return 0; }
  enum Item_result result_type () const { return cached_result_type; }
1156
  enum_field_types field_type() const { return cached_field_type; }
1157
  const char *func_name() const { return "case"; }
1158
  virtual void print(String *str, enum_query_type query_type);
1159 1160
  Item *find_item(String *str);
  CHARSET_INFO *compare_collation() { return cmp_collation.collation; }
1161
  void cleanup();
1162 1163
  void agg_str_lengths(Item *arg);
  void agg_num_lengths(Item *arg);
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179
};

/*
  The Item_func_in class implements the in_expr IN(values_list) function.

  The current implementation distinguishes 2 cases:
  1) all items in the value_list are constants and have the same
    result type. This case is handled by in_vector class.
  2) items in the value_list have different result types or there is some
    non-constant items.
    In this case Item_func_in employs several cmp_item objects to performs
    comparisons of in_expr and an item from the values_list. One cmp_item
    object for each result type. Different result types are collected in the
    fix_length_and_dec() member function by means of collect_cmp_types()
    function.
*/
unknown's avatar
unknown committed
1180
class Item_func_in :public Item_func_opt_neg
unknown's avatar
unknown committed
1181
{
1182
public:
1183 1184 1185 1186
  /* 
    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
1187
  in_vector *array;
1188
  bool have_null;
1189 1190 1191 1192 1193
  /* 
    true when all arguments of the IN clause are of compatible types
    and can be used safely as comparisons for key conditions
  */
  bool arg_types_compatible;
1194
  Item_result left_result_type;
1195
  cmp_item *cmp_items[6]; /* One cmp_item for each result type */
1196
  DTCollation cmp_collation;
1197

1198
  Item_func_in(List<Item> &list)
1199 1200
    :Item_func_opt_neg(list), array(0), have_null(0),
    arg_types_compatible(FALSE)
1201
  {
1202
    bzero(&cmp_items, sizeof(cmp_items));
1203
    allowed_arg_cols= 0;  // Fetch this value from first argument
1204
  }
unknown's avatar
unknown committed
1205
  longlong val_int();
1206
  bool fix_fields(THD *, Item **);
unknown's avatar
unknown committed
1207
  void fix_length_and_dec();
unknown's avatar
unknown committed
1208
  uint decimal_precision() const { return 1; }
1209 1210
  void cleanup()
  {
1211
    uint i;
unknown's avatar
unknown committed
1212
    DBUG_ENTER("Item_func_in::cleanup");
1213
    Item_int_func::cleanup();
1214 1215
    delete array;
    array= 0;
1216
    for (i= 0; i <= (uint)DECIMAL_RESULT + 1; i++)
1217 1218 1219 1220
    {
      delete cmp_items[i];
      cmp_items[i]= 0;
    }
unknown's avatar
unknown committed
1221
    DBUG_VOID_RETURN;
1222
  }
unknown's avatar
unknown committed
1223
  optimize_type select_optimize() const
1224
    { return OPTIMIZE_KEY; }
1225
  virtual void print(String *str, enum_query_type query_type);
unknown's avatar
unknown committed
1226 1227
  enum Functype functype() const { return IN_FUNC; }
  const char *func_name() const { return " IN "; }
unknown's avatar
unknown committed
1228
  bool nulls_in_row();
unknown's avatar
unknown committed
1229
  bool is_bool_func() { return 1; }
1230
  CHARSET_INFO *compare_collation() { return cmp_collation.collation; }
unknown's avatar
unknown committed
1231 1232
};

1233 1234 1235 1236 1237 1238 1239 1240
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);
unknown's avatar
unknown committed
1241
  inline void alloc_comparators();
1242 1243 1244 1245
  int cmp(Item *arg);
  int compare(cmp_item *arg);
  cmp_item *make_same();
  void store_value_by_template(cmp_item *tmpl, Item *);
unknown's avatar
unknown committed
1246
  friend void Item_func_in::fix_length_and_dec();
1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
};


class in_row :public in_vector
{
  cmp_item_row tmp;
public:
  in_row(uint elements, Item *);
  ~in_row();
  void set(uint pos,Item *item);
1257
  uchar *get_value(Item *item);
unknown's avatar
unknown committed
1258
  friend void Item_func_in::fix_length_and_dec();
1259
  Item_result result_type() { return ROW_RESULT; }
unknown's avatar
unknown committed
1260 1261 1262 1263 1264 1265
};

/* Functions used by where clause */

class Item_func_isnull :public Item_bool_func
{
1266
protected:
unknown's avatar
unknown committed
1267
  longlong cached_value;
unknown's avatar
unknown committed
1268 1269 1270 1271 1272 1273 1274
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;
1275
    update_used_tables();
unknown's avatar
unknown committed
1276 1277 1278
  }
  const char *func_name() const { return "isnull"; }
  /* Optimize case of not_null_column IS NULL */
1279
  virtual void update_used_tables()
unknown's avatar
unknown committed
1280 1281 1282
  {
    if (!args[0]->maybe_null)
    {
1283
      used_tables_cache= 0;			/* is always false */
1284
      const_item_cache= 1;
1285
      cached_value= (longlong) 0;
unknown's avatar
unknown committed
1286
    }
1287
    else
unknown's avatar
unknown committed
1288
    {
1289
      args[0]->update_used_tables();
unknown's avatar
unknown committed
1290 1291
      if ((const_item_cache= !(used_tables_cache= args[0]->used_tables())) &&
          !with_subselect)
1292 1293
      {
	/* Remember if the value is always NULL or never NULL */
1294
	cached_value= (longlong) args[0]->is_null();
1295
      }
unknown's avatar
unknown committed
1296
    }
unknown's avatar
unknown committed
1297
  }
1298
  table_map not_null_tables() const { return 0; }
unknown's avatar
unknown committed
1299
  optimize_type select_optimize() const { return OPTIMIZE_NULL; }
1300
  Item *neg_transformer(THD *thd);
1301
  CHARSET_INFO *compare_collation() { return args[0]->collation.collation; }
unknown's avatar
unknown committed
1302 1303
};

1304 1305 1306
/* Functions used by HAVING for rewriting IN subquery */

class Item_in_subselect;
1307 1308 1309 1310 1311

/* 
  This is like IS NOT NULL but it also remembers if it ever has
  encountered a NULL.
*/
1312 1313 1314 1315 1316 1317 1318
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)
  {}
1319
  enum Functype functype() const { return ISNOTNULLTEST_FUNC; }
1320
  longlong val_int();
1321
  const char *func_name() const { return "<is_not_null_test>"; }
1322
  void update_used_tables();
1323 1324 1325 1326 1327
  /*
    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; }
1328 1329 1330
};


unknown's avatar
unknown committed
1331 1332
class Item_func_isnotnull :public Item_bool_func
{
1333
  bool abort_on_null;
unknown's avatar
unknown committed
1334
public:
1335
  Item_func_isnotnull(Item *a) :Item_bool_func(a), abort_on_null(0) {}
unknown's avatar
unknown committed
1336 1337
  longlong val_int();
  enum Functype functype() const { return ISNOTNULL_FUNC; }
unknown's avatar
unknown committed
1338 1339 1340 1341
  void fix_length_and_dec()
  {
    decimals=0; max_length=1; maybe_null=0;
  }
unknown's avatar
unknown committed
1342 1343
  const char *func_name() const { return "isnotnull"; }
  optimize_type select_optimize() const { return OPTIMIZE_NULL; }
1344 1345
  table_map not_null_tables() const
  { return abort_on_null ? not_null_tables_cache : 0; }
1346
  Item *neg_transformer(THD *thd);
1347
  virtual void print(String *str, enum_query_type query_type);
1348
  CHARSET_INFO *compare_collation() { return args[0]->collation.collation; }
1349
  void top_level_item() { abort_on_null=1; }
unknown's avatar
unknown committed
1350 1351
};

1352

unknown's avatar
unknown committed
1353 1354
class Item_func_like :public Item_bool_func2
{
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
  // 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 };

1370
  Item *escape_item;
1371 1372
  
  bool escape_used_in_parsing;
1373

unknown's avatar
unknown committed
1374
public:
unknown's avatar
unknown committed
1375
  int escape;
1376

1377
  Item_func_like(Item *a,Item *b, Item *escape_arg, bool escape_used)
unknown's avatar
unknown committed
1378
    :Item_bool_func2(a,b), canDoTurboBM(FALSE), pattern(0), pattern_len(0), 
1379 1380
     bmGs(0), bmBc(0), escape_item(escape_arg),
     escape_used_in_parsing(escape_used) {}
unknown's avatar
unknown committed
1381 1382 1383 1384 1385
  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"; }
1386
  bool fix_fields(THD *thd, Item **ref);
1387
  void cleanup();
unknown's avatar
unknown committed
1388 1389 1390 1391
};

#ifdef USE_REGEX

unknown's avatar
unknown committed
1392
#include "my_regex.h"
unknown's avatar
unknown committed
1393 1394 1395

class Item_func_regex :public Item_bool_func
{
unknown's avatar
unknown committed
1396
  my_regex_t preg;
unknown's avatar
unknown committed
1397 1398 1399
  bool regex_compiled;
  bool regex_is_const;
  String prev_regexp;
1400
  DTCollation cmp_collation;
1401 1402 1403
  CHARSET_INFO *regex_lib_charset;
  int regex_lib_flags;
  String conv;
1404
  int regcomp(bool send_error);
unknown's avatar
unknown committed
1405 1406 1407
public:
  Item_func_regex(Item *a,Item *b) :Item_bool_func(a,b),
    regex_compiled(0),regex_is_const(0) {}
1408
  void cleanup();
unknown's avatar
unknown committed
1409
  longlong val_int();
1410
  bool fix_fields(THD *thd, Item **ref);
1411
  const char *func_name() const { return "regexp"; }
1412 1413 1414 1415 1416 1417

  virtual inline void print(String *str, enum_query_type query_type)
  {
    print_op(str, query_type);
  }

1418
  CHARSET_INFO *compare_collation() { return cmp_collation.collation; }
unknown's avatar
unknown committed
1419 1420 1421 1422 1423 1424 1425 1426 1427 1428
};

#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"; }
1429 1430 1431 1432 1433

  virtual inline void print(String *str, enum_query_type query_type)
  {
    print_op(str, query_type);
  }
unknown's avatar
unknown committed
1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444
};

#endif /* USE_REGEX */


typedef class Item COND;

class Item_cond :public Item_bool_func
{
protected:
  List<Item> list;
1445
  bool abort_on_null;
1446 1447
  table_map and_tables_cache;

unknown's avatar
unknown committed
1448
public:
1449
  /* Item_cond() is only used to create top level items */
1450 1451
  Item_cond(): Item_bool_func(), abort_on_null(1)
  { const_item_cache=0; }
1452
  Item_cond(Item *i1,Item *i2)
1453 1454 1455 1456 1457
    :Item_bool_func(), abort_on_null(0)
  {
    list.push_back(i1);
    list.push_back(i2);
  }
1458
  Item_cond(THD *thd, Item_cond *item);
1459 1460
  Item_cond(List<Item> &nlist)
    :Item_bool_func(), list(nlist), abort_on_null(0) {}
unknown's avatar
unknown committed
1461
  bool add(Item *item) { return list.push_back(item); }
1462
  bool add_at_head(Item *item) { return list.push_front(item); }
unknown's avatar
unknown committed
1463
  void add_at_head(List<Item> *nlist) { list.prepand(nlist); }
1464
  bool fix_fields(THD *, Item **ref);
unknown's avatar
unknown committed
1465 1466 1467 1468 1469

  enum Type type() const { return COND_ITEM; }
  List<Item>* argument_list() { return &list; }
  table_map used_tables() const;
  void update_used_tables();
1470
  virtual void print(String *str, enum_query_type query_type);
1471
  void split_sum_func(THD *thd, Item **ref_pointer_array, List<Item> &fields);
1472
  friend int setup_conds(THD *thd, TABLE_LIST *tables, TABLE_LIST *leaves,
1473
                         COND **conds);
1474
  void top_level_item() { abort_on_null=1; }
1475
  void copy_andor_arguments(THD *thd, Item_cond *item);
1476 1477
  bool walk(Item_processor processor, bool walk_subquery, uchar *arg);
  Item *transform(Item_transformer transformer, uchar *arg);
1478
  void traverse_cond(Cond_traverser, void *arg, traverse_order order);
1479
  void neg_arguments(THD *thd);
1480
  enum_field_types field_type() const { return MYSQL_TYPE_LONGLONG; }
1481 1482 1483
  bool subst_argument_checker(uchar **arg) { return TRUE; }
  Item *compile(Item_analyzer analyzer, uchar **arg_p,
                Item_transformer transformer, uchar *arg_t);
unknown's avatar
unknown committed
1484 1485 1486
};


unknown's avatar
unknown committed
1487
/*
unknown's avatar
unknown committed
1488
  The class Item_equal is used to represent conjunctions of equality
unknown's avatar
unknown committed
1489 1490
  predicates of the form field1 = field2, and field=const in where
  conditions and on expressions.
1491 1492

  All equality predicates of the form field1=field2 contained in a
unknown's avatar
unknown committed
1493 1494
  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
1495 1496
  multiple equality f1=f2=...=fk.

unknown's avatar
unknown committed
1497
  If a conjunction contains predicates f1=f2 and f2=f3, a new item of
unknown's avatar
unknown committed
1498 1499
  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
1500 1501
  the conjunction.
  A conjunction of the predicates f2=f1 and f3=f1 and f3=f2 will be
unknown's avatar
unknown committed
1502 1503
  substituted for the item representing the same multiple equality
  f1=f2=f3.
unknown's avatar
unknown committed
1504
  An item Item_equal(f1,f2) can appear instead of a conjunction of 
unknown's avatar
unknown committed
1505 1506
  f2=f1 and f1=f2, or instead of just the predicate f1=f2.

unknown's avatar
unknown committed
1507
  An item of the class Item_equal inherits equalities from outer 
unknown's avatar
unknown committed
1508 1509 1510 1511 1512 1513 1514 1515 1516 1517
  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
1518
  item c. Then it represents a multiple equality of the form 
unknown's avatar
unknown committed
1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535
  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
1536
  the occurrence of tj.fj is substituted for ti.fi. This can allow
unknown's avatar
unknown committed
1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548
  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.     
1549 1550 1551 1552 1553 1554

  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.
1555 1556 1557 1558 1559

  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
1560 1561
*/

1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577
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
1578
  uint members();
1579 1580 1581
  bool contains(Field *field);
  Item_field* get_first() { return fields.head(); }
  void merge(Item_equal *item);
1582
  void update_const();
1583 1584 1585 1586
  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
1587
  void sort(Item_field_cmpfunc cmp, void *arg);
1588 1589
  friend class Item_equal_iterator;
  void fix_length_and_dec();
1590
  bool fix_fields(THD *thd, Item **ref);
1591
  void update_used_tables();
1592 1593
  bool walk(Item_processor processor, bool walk_subquery, uchar *arg);
  Item *transform(Item_transformer transformer, uchar *arg);
1594
  virtual void print(String *str, enum_query_type query_type);
unknown's avatar
unknown committed
1595 1596
  CHARSET_INFO *compare_collation() 
  { return fields.head()->collation.collation; }
1597 1598
}; 

unknown's avatar
unknown committed
1599
class COND_EQUAL: public Sql_alloc
1600 1601
{
public:
unknown's avatar
unknown committed
1602 1603 1604 1605 1606 1607 1608 1609 1610
  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;
  }
1611 1612 1613
};


unknown's avatar
unknown committed
1614
class Item_equal_iterator : public List_iterator_fast<Item_field>
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
{
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
1631 1632 1633
class Item_cond_and :public Item_cond
{
public:
unknown's avatar
unknown committed
1634 1635 1636
  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
1637 1638
  Item_cond_and() :Item_cond() {}
  Item_cond_and(Item *i1,Item *i2) :Item_cond(i1,i2) {}
1639
  Item_cond_and(THD *thd, Item_cond_and *item) :Item_cond(thd, item) {}
1640
  Item_cond_and(List<Item> &list_arg): Item_cond(list_arg) {}
unknown's avatar
unknown committed
1641 1642 1643
  enum Functype functype() const { return COND_AND_FUNC; }
  longlong val_int();
  const char *func_name() const { return "and"; }
1644 1645
  table_map not_null_tables() const
  { return abort_on_null ? not_null_tables_cache: and_tables_cache; }
1646 1647 1648
  Item* copy_andor_structure(THD *thd)
  {
    Item_cond_and *item;
unknown's avatar
merge  
unknown committed
1649
    if ((item= new Item_cond_and(thd, this)))
1650 1651 1652
       item->copy_andor_arguments(thd, this);
    return item;
  }
1653
  Item *neg_transformer(THD *thd);
unknown's avatar
unknown committed
1654 1655
};

1656 1657 1658 1659 1660 1661 1662 1663 1664
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
1665 1666 1667 1668 1669
class Item_cond_or :public Item_cond
{
public:
  Item_cond_or() :Item_cond() {}
  Item_cond_or(Item *i1,Item *i2) :Item_cond(i1,i2) {}
1670
  Item_cond_or(THD *thd, Item_cond_or *item) :Item_cond(thd, item) {}
1671
  Item_cond_or(List<Item> &list_arg): Item_cond(list_arg) {}
unknown's avatar
unknown committed
1672 1673 1674
  enum Functype functype() const { return COND_OR_FUNC; }
  longlong val_int();
  const char *func_name() const { return "or"; }
1675
  table_map not_null_tables() const { return and_tables_cache; }
1676 1677 1678
  Item* copy_andor_structure(THD *thd)
  {
    Item_cond_or *item;
unknown's avatar
merge  
unknown committed
1679
    if ((item= new Item_cond_or(thd, this)))
1680 1681 1682
      item->copy_andor_arguments(thd, this);
    return item;
  }
1683
  Item *neg_transformer(THD *thd);
unknown's avatar
unknown committed
1684 1685
};

1686 1687 1688 1689 1690 1691 1692 1693
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
1694

1695
/*
unknown's avatar
unknown committed
1696
  XOR is Item_cond, not an Item_int_func because we could like to
1697 1698
  optimize (a XOR b) later on. It's low prio, though
*/
unknown's avatar
unknown committed
1699

unknown's avatar
unknown committed
1700 1701 1702 1703 1704 1705
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; }
1706 1707
  /* TODO: remove the next line when implementing XOR optimization */
  enum Type type() const { return FUNC_ITEM; }
unknown's avatar
unknown committed
1708 1709
  longlong val_int();
  const char *func_name() const { return "xor"; }
1710
  void top_level_item() {}
unknown's avatar
unknown committed
1711 1712 1713
};


unknown's avatar
unknown committed
1714
/* Some useful inline functions */
unknown's avatar
unknown committed
1715

unknown's avatar
unknown committed
1716
inline Item *and_conds(Item *a, Item *b)
unknown's avatar
unknown committed
1717 1718 1719
{
  if (!b) return a;
  if (!a) return b;
unknown's avatar
unknown committed
1720
  return new Item_cond_and(a, b);
unknown's avatar
unknown committed
1721
}
unknown's avatar
unknown committed
1722

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