item_cmpfunc.cc 88.1 KB
Newer Older
1
/* Copyright (C) 2000-2003 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3 4 5 6
   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
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
7

bk@work.mysql.com's avatar
bk@work.mysql.com committed
8 9 10 11
   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.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
12

bk@work.mysql.com's avatar
bk@work.mysql.com committed
13 14 15 16 17 18 19
   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 */


/* This file defines all compare functions */

20
#ifdef USE_PRAGMA_IMPLEMENTATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
21 22 23 24 25
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
#include <m_ctype.h>
26
#include "sql_select.h"
27

28 29 30 31 32 33
static Item_result item_store_type(Item_result a,Item_result b)
{
  if (a == STRING_RESULT || b == STRING_RESULT)
    return STRING_RESULT;
  else if (a == REAL_RESULT || b == REAL_RESULT)
    return REAL_RESULT;
34 35
  else if (a == DECIMAL_RESULT || b == DECIMAL_RESULT)
    return DECIMAL_RESULT;
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
  else
    return INT_RESULT;
}

static void agg_result_type(Item_result *type, Item **items, uint nitems)
{
  uint i;
  type[0]= items[0]->result_type();
  for (i=1 ; i < nitems ; i++)
    type[0]= item_store_type(type[0], items[i]->result_type());
}

static void agg_cmp_type(Item_result *type, Item **items, uint nitems)
{
  uint i;
  type[0]= items[0]->result_type();
  for (i=1 ; i < nitems ; i++)
    type[0]= item_cmp_type(type[0], items[i]->result_type());
}

56 57
static void my_coll_agg_error(DTCollation &c1, DTCollation &c2,
                              const char *fname)
58
{
59 60 61 62
  my_error(ER_CANT_AGGREGATE_2COLLATIONS, MYF(0),
           c1.collation->name,c1.derivation_name(),
           c2.collation->name,c2.derivation_name(),
           fname);
63 64
}

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
65 66

Item_bool_func2* Eq_creator::create(Item *a, Item *b) const
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
67 68 69
{
  return new Item_func_eq(a, b);
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
70 71 72


Item_bool_func2* Ne_creator::create(Item *a, Item *b) const
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
73 74 75
{
  return new Item_func_ne(a, b);
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
76 77 78


Item_bool_func2* Gt_creator::create(Item *a, Item *b) const
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
79 80 81
{
  return new Item_func_gt(a, b);
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
82 83 84


Item_bool_func2* Lt_creator::create(Item *a, Item *b) const
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
85 86 87
{
  return new Item_func_lt(a, b);
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
88 89 90


Item_bool_func2* Ge_creator::create(Item *a, Item *b) const
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
91 92 93
{
  return new Item_func_ge(a, b);
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
94 95 96


Item_bool_func2* Le_creator::create(Item *a, Item *b) const
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
97 98 99
{
  return new Item_func_le(a, b);
}
100

bk@work.mysql.com's avatar
bk@work.mysql.com committed
101
/*
102
  Test functions
103 104
  Most of these  returns 0LL if false and 1LL if true and
  NULL if some arg is NULL.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
105 106 107 108
*/

longlong Item_func_not::val_int()
{
109
  DBUG_ASSERT(fixed == 1);
110
  bool value= args[0]->val_bool();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
111
  null_value=args[0]->null_value;
112
  return ((!null_value && value == 0) ? 1 : 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
113 114
}

115 116 117 118 119
/*
  special NOT for ALL subquery
*/

longlong Item_func_not_all::val_int()
120 121
{
  DBUG_ASSERT(fixed == 1);
122
  bool value= args[0]->val_bool();
123 124

  /*
125 126
    return TRUE if there was records in underlying select in max/min
    optimization (ALL subquery)
127 128 129 130
  */
  if (empty_underlying_subquery())
    return 1;

131
  null_value= args[0]->null_value;
132 133 134 135 136 137 138 139
  return ((!null_value && value == 0) ? 1 : 0);
}


bool Item_func_not_all::empty_underlying_subquery()
{
  return ((test_sum_item && !test_sum_item->any_value()) ||
          (test_sub_item && !test_sub_item->any_value()));
140 141
}

142 143 144 145 146 147 148 149
void Item_func_not_all::print(String *str)
{
  if (show)
    Item_func::print(str);
  else
    args[0]->print(str);
}

150 151

/*
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
152
  Special NOP (No OPeration) for ALL subquery it is like  Item_func_not_all
153
  (return TRUE if underlying subquery do not return rows) but if subquery
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
154
  returns some rows it return same value as argument (TRUE/FALSE).
155 156 157 158 159
*/

longlong Item_func_nop_all::val_int()
{
  DBUG_ASSERT(fixed == 1);
monty@mysql.com's avatar
monty@mysql.com committed
160
  longlong value= args[0]->val_int();
161 162

  /*
163 164
    return FALSE if there was records in underlying select in max/min
    optimization (SAME/ANY subquery)
165 166
  */
  if (empty_underlying_subquery())
167
    return 0;
168 169 170 171 172 173

  null_value= args[0]->null_value;
  return (null_value || value == 0) ? 0 : 1;
}


174 175 176 177 178
/*
  Convert a constant expression or string to an integer.
  This is done when comparing DATE's of different formats and
  also when comparing bigint to strings (in which case the string
  is converted once to a bigint).
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
179 180 181 182

  RESULT VALUES
  0	Can't convert item
  1	Item was replaced with an integer version of the item
183
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
184

185
static bool convert_constant_item(THD *thd, Field *field, Item **item)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
186
{
187
  if ((*item)->const_item())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
188
  {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
189
    if (!(*item)->save_in_field(field, 1) && !((*item)->null_value))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
190
    {
191 192
      Item *tmp=new Item_int_with_ref(field->val_int(), *item);
      if (tmp)
193
        thd->change_item_tree(item, tmp);
194
      return 1;					// Item was replaced
bk@work.mysql.com's avatar
bk@work.mysql.com committed
195 196 197 198 199
    }
  }
  return 0;
}

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
200

201 202 203
void Item_bool_func2::fix_length_and_dec()
{
  max_length= 1;				     // Function returns 0 or 1
204
  THD *thd= current_thd;
205 206 207 208 209 210 211

  /*
    As some compare functions are generated after sql_yacc,
    we have to check for out of memory conditions here
  */
  if (!args[0] || !args[1])
    return;
212 213 214 215 216 217 218 219 220 221 222 223 224

  /* 
    We allow to convert to Unicode character sets in some cases.
    The conditions when conversion is possible are:
    - arguments A and B have different charsets
    - A wins according to coercibility rules
    - character set of A is superset for character set of B
   
    If all of the above is true, then it's possible to convert
    B into the character set of A, and then compare according
    to the collation of A.
  */

225
  
226 227 228
  DTCollation coll;
  if (args[0]->result_type() == STRING_RESULT &&
      args[1]->result_type() == STRING_RESULT &&
bar@mysql.com's avatar
bar@mysql.com committed
229 230
      agg_arg_charsets(coll, args, 2, MY_COLL_CMP_CONV))
    return;
231 232
    
 
bk@work.mysql.com's avatar
bk@work.mysql.com committed
233
  // Make a special case of compare with fields to get nicer DATE comparisons
234 235 236 237 238 239

  if (functype() == LIKE_FUNC)  // Disable conversion in case of LIKE function.
  {
    set_cmp_func();
    return;
  }
240 241

  if (!thd->is_context_analysis_only())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
242
  {
243 244
    Item *real_item= args[0]->real_item();
    if (real_item->type() == FIELD_ITEM)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
245
    {
246
      Field *field=((Item_field*) real_item)->field;
247
      if (field->can_be_compared_as_longlong())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
248
      {
249 250 251 252 253 254
        if (convert_constant_item(thd, field,&args[1]))
        {
          cmp.set_cmp_func(this, tmp_arg, tmp_arg+1,
                           INT_RESULT);		// Works for all types.
          return;
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
255 256
      }
    }
257 258
    real_item= args[1]->real_item();
    if (real_item->type() == FIELD_ITEM /* && !real_item->const_item() */)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
259
    {
260
      Field *field=((Item_field*) real_item)->field;
261
      if (field->can_be_compared_as_longlong())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
262
      {
263 264 265 266 267 268
        if (convert_constant_item(thd, field,&args[0]))
        {
          cmp.set_cmp_func(this, tmp_arg, tmp_arg+1,
                           INT_RESULT); // Works for all types.
          return;
        }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
269 270 271
      }
    }
  }
272
  set_cmp_func();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
273 274
}

275

276
int Arg_comparator::set_compare_func(Item_bool_func2 *item, Item_result type)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
277
{
278
  owner= item;
serg@serg.mylan's avatar
serg@serg.mylan committed
279 280
  func= comparator_matrix[type]
                         [test(owner->functype() == Item_func::EQUAL_FUNC)];
281
  switch (type) {
282
  case ROW_RESULT:
283
  {
284 285
    uint n= (*a)->cols();
    if (n != (*b)->cols())
286
    {
287
      my_error(ER_OPERAND_COLUMNS, MYF(0), n);
288 289 290
      comparators= 0;
      return 1;
    }
291
    if (!(comparators= new Arg_comparator[n]))
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
292 293 294 295
      return 1;
    for (uint i=0; i < n; i++)
    {
      if ((*a)->el(i)->cols() != (*b)->el(i)->cols())
296
      {
297
	my_error(ER_OPERAND_COLUMNS, MYF(0), (*a)->el(i)->cols());
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
298
	return 1;
299
      }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
300 301
      comparators[i].set_cmp_func(owner, (*a)->addr(i), (*b)->addr(i));
    }
302
    break;
303
  }
304
  case STRING_RESULT:
305 306 307 308 309
  {
    /*
      We must set cmp_charset here as we may be called from for an automatic
      generated item, like in natural join
    */
310 311
    if (cmp_collation.set((*a)->collation, (*b)->collation) || 
	cmp_collation.derivation == DERIVATION_NONE)
312 313 314 315
    {
      my_coll_agg_error((*a)->collation, (*b)->collation, owner->func_name());
      return 1;
    }
316
    if (cmp_collation.collation == &my_charset_bin)
monty@mysql.com's avatar
monty@mysql.com committed
317 318
    {
      /*
319
	We are using BLOB/BINARY/VARBINARY, change to compare byte by byte,
monty@mysql.com's avatar
monty@mysql.com committed
320 321 322 323 324 325
	without removing end space
      */
      if (func == &Arg_comparator::compare_string)
	func= &Arg_comparator::compare_binary_string;
      else if (func == &Arg_comparator::compare_e_string)
	func= &Arg_comparator::compare_e_binary_string;
monty@mysql.com's avatar
monty@mysql.com committed
326 327

      /*
328
        As this is binary compassion, mark all fields that they can't be
monty@mysql.com's avatar
monty@mysql.com committed
329 330 331 332 333 334 335 336
        transformed. Otherwise we would get into trouble with comparisons
        like:
        WHERE col= 'j' AND col LIKE BINARY 'j'
        which would be transformed to:
        WHERE col= 'j'
      */
      (*a)->transform(&Item::set_no_const_sub, (byte*) 0);
      (*b)->transform(&Item::set_no_const_sub, (byte*) 0);
monty@mysql.com's avatar
monty@mysql.com committed
337
    }
338
    break;
339
  }
340
  case INT_RESULT:
341
  {
342
    if (func == &Arg_comparator::compare_int_signed)
343 344
    {
      if ((*a)->unsigned_flag)
345 346 347
        func= (((*b)->unsigned_flag)?
               &Arg_comparator::compare_int_unsigned :
               &Arg_comparator::compare_int_unsigned_signed);
348 349 350
      else if ((*b)->unsigned_flag)
        func= &Arg_comparator::compare_int_signed_unsigned;
    }
351 352 353 354 355
    else if (func== &Arg_comparator::compare_e_int)
    {
      if ((*a)->unsigned_flag ^ (*b)->unsigned_flag)
        func= &Arg_comparator::compare_e_int_diff_signedness;
    }
356 357 358 359 360 361 362
    break;
  }
  case DECIMAL_RESULT:
  case REAL_RESULT:
    break;
  default:
    DBUG_ASSERT(0);
363
  }
364
  return 0;
365
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
366

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
367

368
int Arg_comparator::compare_string()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
369 370
{
  String *res1,*res2;
371
  if ((res1= (*a)->val_str(&owner->tmp_value1)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
372
  {
373
    if ((res2= (*b)->val_str(&owner->tmp_value2)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
374
    {
375
      owner->null_value= 0;
376
      return sortcmp(res1,res2,cmp_collation.collation);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
377 378
    }
  }
379
  owner->null_value= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
380 381 382
  return -1;
}

monty@mysql.com's avatar
monty@mysql.com committed
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415

/*
  Compare strings byte by byte. End spaces are also compared.

  RETURN
   < 0	*a < *b
   0	*b == *b
   > 0	*a > *b
*/

int Arg_comparator::compare_binary_string()
{
  String *res1,*res2;
  if ((res1= (*a)->val_str(&owner->tmp_value1)))
  {
    if ((res2= (*b)->val_str(&owner->tmp_value2)))
    {
      owner->null_value= 0;
      uint res1_length= res1->length();
      uint res2_length= res2->length();
      int cmp= memcmp(res1->ptr(), res2->ptr(), min(res1_length,res2_length));
      return cmp ? cmp : (int) (res1_length - res2_length);
    }
  }
  owner->null_value= 1;
  return -1;
}


/*
  Compare strings, but take into account that NULL == NULL
*/

416 417 418
int Arg_comparator::compare_e_string()
{
  String *res1,*res2;
419 420
  res1= (*a)->val_str(&owner->tmp_value1);
  res2= (*b)->val_str(&owner->tmp_value2);
421 422
  if (!res1 || !res2)
    return test(res1 == res2);
423
  return test(sortcmp(res1, res2, cmp_collation.collation) == 0);
424 425 426
}


monty@mysql.com's avatar
monty@mysql.com committed
427 428 429 430 431 432 433 434 435 436 437
int Arg_comparator::compare_e_binary_string()
{
  String *res1,*res2;
  res1= (*a)->val_str(&owner->tmp_value1);
  res2= (*b)->val_str(&owner->tmp_value2);
  if (!res1 || !res2)
    return test(res1 == res2);
  return test(stringcmp(res1, res2) == 0);
}


438
int Arg_comparator::compare_real()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
439
{
440 441 442 443 444 445
  /*
    Fix yet another manifestation of Bug#2338. 'Volatile' will instruct
    gcc to flush double values out of 80-bit Intel FPU registers before
    performing the comparison.
  */
  volatile double val1, val2;
pekka@mysql.com's avatar
Merge  
pekka@mysql.com committed
446
  val1= (*a)->val_real();
447
  if (!(*a)->null_value)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
448
  {
pekka@mysql.com's avatar
Merge  
pekka@mysql.com committed
449
    val2= (*b)->val_real();
450
    if (!(*b)->null_value)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
451
    {
452
      owner->null_value= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
453 454 455 456 457
      if (val1 < val2)	return -1;
      if (val1 == val2) return 0;
      return 1;
    }
  }
458
  owner->null_value= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
459 460 461
  return -1;
}

462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
int Arg_comparator::compare_decimal()
{
  my_decimal value1;
  my_decimal *val1= (*a)->val_decimal(&value1);
  if (!(*a)->null_value)
  {
    my_decimal value2;
    my_decimal *val2= (*b)->val_decimal(&value2);
    if (!(*b)->null_value)
    {
      owner->null_value= 0;
      return my_decimal_cmp(val1, val2);
    }
  }
  owner->null_value= 1;
  return -1;
}

480 481
int Arg_comparator::compare_e_real()
{
482 483
  double val1= (*a)->val_real();
  double val2= (*b)->val_real();
484 485
  if ((*a)->null_value || (*b)->null_value)
    return test((*a)->null_value && (*b)->null_value);
486 487
  return test(val1 == val2);
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
488

489 490 491 492 493 494 495 496 497 498
int Arg_comparator::compare_e_decimal()
{
  my_decimal value1, value2;
  my_decimal *val1= (*a)->val_decimal(&value1);
  my_decimal *val2= (*b)->val_decimal(&value2);
  if ((*a)->null_value || (*b)->null_value)
    return test((*a)->null_value && (*b)->null_value);
  return test(my_decimal_cmp(val1, val2) == 0);
}

499
int Arg_comparator::compare_int_signed()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
500
{
501 502
  longlong val1= (*a)->val_int();
  if (!(*a)->null_value)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
503
  {
504 505
    longlong val2= (*b)->val_int();
    if (!(*b)->null_value)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
506
    {
507
      owner->null_value= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
508 509 510 511 512
      if (val1 < val2)	return -1;
      if (val1 == val2)   return 0;
      return 1;
    }
  }
513
  owner->null_value= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
514 515 516
  return -1;
}

517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 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 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592

/*
  Compare values as BIGINT UNSIGNED.
*/

int Arg_comparator::compare_int_unsigned()
{
  ulonglong val1= (*a)->val_int();
  if (!(*a)->null_value)
  {
    ulonglong val2= (*b)->val_int();
    if (!(*b)->null_value)
    {
      owner->null_value= 0;
      if (val1 < val2)	return -1;
      if (val1 == val2)   return 0;
      return 1;
    }
  }
  owner->null_value= 1;
  return -1;
}


/*
  Compare signed (*a) with unsigned (*B)
*/

int Arg_comparator::compare_int_signed_unsigned()
{
  longlong sval1= (*a)->val_int();
  if (!(*a)->null_value)
  {
    ulonglong uval2= (ulonglong)(*b)->val_int();
    if (!(*b)->null_value)
    {
      owner->null_value= 0;
      if (sval1 < 0 || (ulonglong)sval1 < uval2)
        return -1;
      if ((ulonglong)sval1 == uval2)
        return 0;
      return 1;
    }
  }
  owner->null_value= 1;
  return -1;
}


/*
  Compare unsigned (*a) with signed (*B)
*/

int Arg_comparator::compare_int_unsigned_signed()
{
  ulonglong uval1= (ulonglong)(*a)->val_int();
  if (!(*a)->null_value)
  {
    longlong sval2= (*b)->val_int();
    if (!(*b)->null_value)
    {
      owner->null_value= 0;
      if (sval2 < 0)
        return 1;
      if (uval1 < (ulonglong)sval2)
        return -1;
      if (uval1 == (ulonglong)sval2)
        return 0;
      return 1;
    }
  }
  owner->null_value= 1;
  return -1;
}


593 594
int Arg_comparator::compare_e_int()
{
595 596 597 598
  longlong val1= (*a)->val_int();
  longlong val2= (*b)->val_int();
  if ((*a)->null_value || (*b)->null_value)
    return test((*a)->null_value && (*b)->null_value);
599 600 601
  return test(val1 == val2);
}

602 603 604 605 606 607 608 609 610 611 612
/*
  Compare unsigned *a with signed *b or signed *a with unsigned *b.
*/
int Arg_comparator::compare_e_int_diff_signedness()
{
  longlong val1= (*a)->val_int();
  longlong val2= (*b)->val_int();
  if ((*a)->null_value || (*b)->null_value)
    return test((*a)->null_value && (*b)->null_value);
  return (val1 >= 0) && test(val1 == val2);
}
613

614
int Arg_comparator::compare_row()
615 616
{
  int res= 0;
617
  bool was_null= 0;
618 619
  (*a)->bring_value();
  (*b)->bring_value();
620
  uint n= (*a)->cols();
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
621
  for (uint i= 0; i<n; i++)
622
  {
623
    res= comparators[i].compare();
624
    if (owner->null_value)
625 626 627 628 629 630 631 632
    {
      // NULL was compared
      if (owner->abort_on_null)
        return -1; // We do not need correct NULL returning
      was_null= 1;
      owner->null_value= 0;
      res= 0;  // continue comparison (maybe we will meet explicit difference)
    }
633
    else if (res)
634
      return res;
635
  }
636 637 638 639 640 641 642 643 644 645
  if (was_null)
  {
    /*
      There was NULL(s) in comparison in some parts, but there was not
      explicit difference in other parts, so we have to return NULL
    */
    owner->null_value= 1;
    return -1;
  }
  return 0;
646
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
647

648

649 650
int Arg_comparator::compare_e_row()
{
651 652
  (*a)->bring_value();
  (*b)->bring_value();
653
  uint n= (*a)->cols();
654 655
  for (uint i= 0; i<n; i++)
  {
656
    if (!comparators[i].compare())
657
      return 0;
658 659 660 661
  }
  return 1;
}

662

663
bool Item_in_optimizer::fix_left(THD *thd, Item **ref)
664
{
665
  if (!args[0]->fixed && args[0]->fix_fields(thd, args) ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
666
      !cache && !(cache= Item_cache::get_cache(args[0]->result_type())))
667
    return 1;
668

669
  cache->setup(args[0]);
670 671 672 673
  /*
    If it is preparation PS only then we do not know values of parameters =>
    cant't get there values and do not need that values.
  */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
674
  if (!thd->stmt_arena->is_stmt_prepare())
675
    cache->store(args[0]);
676
  if (cache->cols() == 1)
677
  {
678
    if ((used_tables_cache= args[0]->used_tables()))
679
      cache->set_used_tables(OUTER_REF_TABLE_BIT);
680 681 682
    else
      cache->set_used_tables(0);
  }
683 684 685 686
  else
  {
    uint n= cache->cols();
    for (uint i= 0; i < n; i++)
687 688
    {
      if (args[0]->el(i)->used_tables())
689
	((Item_cache *)cache->el(i))->set_used_tables(OUTER_REF_TABLE_BIT);
690 691 692
      else
	((Item_cache *)cache->el(i))->set_used_tables(0);
    }
693
    used_tables_cache= args[0]->used_tables();
694
  }
695 696 697
  not_null_tables_cache= args[0]->not_null_tables();
  with_sum_func= args[0]->with_sum_func;
  const_item_cache= args[0]->const_item();
698 699 700 701
  return 0;
}


702
bool Item_in_optimizer::fix_fields(THD *thd, Item **ref)
703
{
704
  DBUG_ASSERT(fixed == 0);
705
  if (fix_left(thd, ref))
706
    return TRUE;
707 708 709
  if (args[0]->maybe_null)
    maybe_null=1;

710
  if (!args[1]->fixed && args[1]->fix_fields(thd, args+1))
711
    return TRUE;
712 713 714
  Item_in_subselect * sub= (Item_in_subselect *)args[1];
  if (args[0]->cols() != sub->engine->cols())
  {
715
    my_error(ER_OPERAND_COLUMNS, MYF(0), args[0]->cols());
716
    return TRUE;
717
  }
718 719 720 721
  if (args[1]->maybe_null)
    maybe_null=1;
  with_sum_func= with_sum_func || args[1]->with_sum_func;
  used_tables_cache|= args[1]->used_tables();
722
  not_null_tables_cache|= args[1]->not_null_tables();
723
  const_item_cache&= args[1]->const_item();
724
  fixed= 1;
725
  return FALSE;
726 727
}

728

729 730
longlong Item_in_optimizer::val_int()
{
731
  DBUG_ASSERT(fixed == 1);
732 733
  cache->store(args[0]);
  if (cache->null_value)
734
  {
735
    null_value= 1;
736 737
    return 0;
  }
738
  bool tmp= args[1]->val_bool_result();
739
  null_value= args[1]->null_value;
740 741 742
  return tmp;
}

743 744 745 746 747 748 749 750

void Item_in_optimizer::keep_top_level_cache()
{
  cache->keep_array();
  save_cache= 1;
}


751 752 753 754
void Item_in_optimizer::cleanup()
{
  DBUG_ENTER("Item_in_optimizer::cleanup");
  Item_bool_func::cleanup();
755 756
  if (!save_cache)
    cache= 0;
757 758 759
  DBUG_VOID_RETURN;
}

760

761
bool Item_in_optimizer::is_null()
762
{
763 764
  cache->store(args[0]);
  return (null_value= (cache->null_value || args[1]->is_null()));
765
}
766

767

bk@work.mysql.com's avatar
bk@work.mysql.com committed
768 769
longlong Item_func_eq::val_int()
{
770
  DBUG_ASSERT(fixed == 1);
771
  int value= cmp.compare();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
772 773 774
  return value == 0 ? 1 : 0;
}

775

bk@work.mysql.com's avatar
bk@work.mysql.com committed
776 777
/* Same as Item_func_eq, but NULL = NULL */

monty@donna.mysql.com's avatar
monty@donna.mysql.com committed
778 779 780 781 782 783
void Item_func_equal::fix_length_and_dec()
{
  Item_bool_func2::fix_length_and_dec();
  maybe_null=null_value=0;
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
784 785
longlong Item_func_equal::val_int()
{
786
  DBUG_ASSERT(fixed == 1);
787
  return cmp.compare();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
788 789 790 791
}

longlong Item_func_ne::val_int()
{
792
  DBUG_ASSERT(fixed == 1);
793
  int value= cmp.compare();
794
  return value != 0 && !null_value ? 1 : 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
795 796 797 798 799
}


longlong Item_func_ge::val_int()
{
800
  DBUG_ASSERT(fixed == 1);
801
  int value= cmp.compare();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
802 803 804 805 806 807
  return value >= 0 ? 1 : 0;
}


longlong Item_func_gt::val_int()
{
808
  DBUG_ASSERT(fixed == 1);
809
  int value= cmp.compare();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
810 811 812 813 814
  return value > 0 ? 1 : 0;
}

longlong Item_func_le::val_int()
{
815
  DBUG_ASSERT(fixed == 1);
816
  int value= cmp.compare();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
817 818 819 820 821 822
  return value <= 0 && !null_value ? 1 : 0;
}


longlong Item_func_lt::val_int()
{
823
  DBUG_ASSERT(fixed == 1);
824
  int value= cmp.compare();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
825 826 827 828 829 830
  return value < 0 && !null_value ? 1 : 0;
}


longlong Item_func_strcmp::val_int()
{
831
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
832 833 834 835 836 837 838
  String *a=args[0]->val_str(&tmp_value1);
  String *b=args[1]->val_str(&tmp_value2);
  if (!a || !b)
  {
    null_value=1;
    return 0;
  }
839
  int value= sortcmp(a,b,cmp.cmp_collation.collation);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
840 841 842 843 844 845 846
  null_value=0;
  return !value ? 0 : (value < 0 ? (longlong) -1 : (longlong) 1);
}


void Item_func_interval::fix_length_and_dec()
{
847 848
  use_decimal_comparison= (row->el(0)->result_type() == DECIMAL_RESULT) ||
    (row->el(0)->result_type() == INT_RESULT);
849
  if (row->cols() > 8)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
850
  {
851 852 853
    bool consts=1;

    for (uint i=1 ; consts && i < row->cols() ; i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
854
    {
855
      consts&= row->el(i)->const_item();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
856
    }
857 858

    if (consts &&
859 860
        (intervals=
          (interval_range*) sql_alloc(sizeof(interval_range)*(row->cols()-1))))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
861
    {
862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893
      if (use_decimal_comparison)
      {
        for (uint i=1 ; i < row->cols(); i++)
        {
          Item *el= row->el(i);
          interval_range *range= intervals + (i-1);
          if ((el->result_type() == DECIMAL_RESULT) ||
              (el->result_type() == INT_RESULT))
          {
            range->type= DECIMAL_RESULT;
            range->dec.init();
            my_decimal *dec= el->val_decimal(&range->dec);
            if (dec != &range->dec)
            {
              range->dec= *dec;
              range->dec.fix_buffer_pointer();
            }
          }
          else
          {
            range->type= REAL_RESULT;
            range->dbl= el->val_real();
          }
        }
      }
      else
      {
        for (uint i=1 ; i < row->cols(); i++)
        {
          intervals[i-1].dbl= row->el(i)->val_real();
        }
      }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
894 895
    }
  }
896 897
  maybe_null= 0;
  max_length= 2;
898
  used_tables_cache|= row->used_tables();
serg@serg.mylan's avatar
serg@serg.mylan committed
899
  not_null_tables_cache= row->not_null_tables();
900
  with_sum_func= with_sum_func || row->with_sum_func;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
901
  const_item_cache&= row->const_item();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
902 903
}

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
904

bk@work.mysql.com's avatar
bk@work.mysql.com committed
905
/*
monty@mysql.com's avatar
monty@mysql.com committed
906 907 908 909 910 911 912 913 914 915 916 917 918 919
  Execute Item_func_interval()

  SYNOPSIS
    Item_func_interval::val_int()

  NOTES
    If we are doing a decimal comparison, we are
    evaluating the first item twice.

  RETURN
    -1 if null value,
    0 if lower than lowest
    1 - arg_count-1 if between args[n] and args[n+1]
    arg_count if higher than biggest argument
bk@work.mysql.com's avatar
bk@work.mysql.com committed
920 921 922 923
*/

longlong Item_func_interval::val_int()
{
924
  DBUG_ASSERT(fixed == 1);
925
  double value;
926
  my_decimal dec_buf, *dec= NULL;
monty@mysql.com's avatar
monty@mysql.com committed
927 928
  uint i;

929 930 931
  if (use_decimal_comparison)
  {
    dec= row->el(0)->val_decimal(&dec_buf);
932 933 934 935 936 937 938 939 940
    if (row->el(0)->null_value)
      return -1;
    my_decimal2double(E_DEC_FATAL_ERROR, dec, &value);
  }
  else
  {
    value= row->el(0)->val_real();
    if (row->el(0)->null_value)
      return -1;
941
  }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
942

bk@work.mysql.com's avatar
bk@work.mysql.com committed
943 944 945
  if (intervals)
  {					// Use binary search to find interval
    uint start,end;
946
    start= 0;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
947
    end=   row->cols()-2;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
948 949
    while (start != end)
    {
ram@mysql.r18.ru's avatar
ram@mysql.r18.ru committed
950
      uint mid= (start + end + 1) / 2;
951 952
      interval_range *range= intervals + mid;
      my_bool cmp_result;
monty@mysql.com's avatar
monty@mysql.com committed
953 954 955 956 957
      /*
        The values in the range intervall may have different types,
        Only do a decimal comparision of the first argument is a decimal
        and we are comparing against a decimal
      */
958 959 960 961 962
      if (dec && range->type == DECIMAL_RESULT)
        cmp_result= my_decimal_cmp(&range->dec, dec) <= 0;
      else
        cmp_result= (range->dbl <= value);
      if (cmp_result)
ram@mysql.r18.ru's avatar
ram@mysql.r18.ru committed
963
	start= mid;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
964
      else
ram@mysql.r18.ru's avatar
ram@mysql.r18.ru committed
965
	end= mid - 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
966
    }
967 968
    interval_range *range= intervals+start;
    return ((dec && range->type == DECIMAL_RESULT) ?
monty@mysql.com's avatar
monty@mysql.com committed
969
            my_decimal_cmp(dec, &range->dec) < 0 :
970
            value < range->dbl) ? 0 : start + 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
971
  }
972 973

  for (i=1 ; i < row->cols() ; i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
974
  {
975 976 977 978 979 980 981 982 983
    Item *el= row->el(i);
    if (use_decimal_comparison &&
        ((el->result_type() == DECIMAL_RESULT) ||
         (el->result_type() == INT_RESULT)))
    {
      my_decimal e_dec_buf, *e_dec= row->el(i)->val_decimal(&e_dec_buf);
      if (my_decimal_cmp(e_dec, dec) > 0)
        return i-1;
    }
monty@mysql.com's avatar
monty@mysql.com committed
984 985
    else if (row->el(i)->val_real() > value)
      return i-1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
986
  }
987
  return i-1;
988 989
}

monty@mysql.com's avatar
monty@mysql.com committed
990

aivanov@mysql.com's avatar
aivanov@mysql.com committed
991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019
/*
  Perform context analysis of a BETWEEN item tree

  SYNOPSIS:
    fix_fields()
    thd     reference to the global context of the query thread
    tables  list of all open tables involved in the query
    ref     pointer to Item* variable where pointer to resulting "fixed"
            item is to be assigned

  DESCRIPTION
    This function performs context analysis (name resolution) and calculates
    various attributes of the item tree with Item_func_between as its root.
    The function saves in ref the pointer to the item or to a newly created
    item that is considered as a replacement for the original one.

  NOTES
    Let T0(e)/T1(e) be the value of not_null_tables(e) when e is used on
    a predicate/function level. Then it's easy to show that:
      T0(e BETWEEN e1 AND e2)     = union(T1(e),T1(e1),T1(e2))
      T1(e BETWEEN e1 AND e2)     = union(T1(e),intersection(T1(e1),T1(e2)))
      T0(e NOT BETWEEN e1 AND e2) = union(T1(e),intersection(T1(e1),T1(e2)))
      T1(e NOT BETWEEN e1 AND e2) = union(T1(e),intersection(T1(e1),T1(e2)))

  RETURN
    0   ok
    1   got error
*/

1020
bool Item_func_between::fix_fields(THD *thd, Item **ref)
aivanov@mysql.com's avatar
aivanov@mysql.com committed
1021
{
1022
  if (Item_func_opt_neg::fix_fields(thd, ref))
aivanov@mysql.com's avatar
aivanov@mysql.com committed
1023 1024 1025 1026 1027 1028 1029
    return 1;

  /* not_null_tables_cache == union(T1(e),T1(e1),T1(e2)) */
  if (pred_level && !negated)
    return 0;

  /* not_null_tables_cache == union(T1(e), intersection(T1(e1),T1(e2))) */
1030 1031 1032
  not_null_tables_cache= (args[0]->not_null_tables() |
                          (args[1]->not_null_tables() &
                           args[2]->not_null_tables()));
aivanov@mysql.com's avatar
aivanov@mysql.com committed
1033 1034 1035 1036 1037

  return 0;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1038 1039
void Item_func_between::fix_length_and_dec()
{
1040
   max_length= 1;
1041
   THD *thd= current_thd;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1042

1043 1044
  /*
    As some compare functions are generated after sql_yacc,
1045
    we have to check for out of memory conditions here
1046
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1047 1048
  if (!args[0] || !args[1] || !args[2])
    return;
1049
  agg_cmp_type(&cmp_type, args, 3);
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1050
  if (cmp_type == STRING_RESULT &&
bar@mysql.com's avatar
bar@mysql.com committed
1051
      agg_arg_charsets(cmp_collation, args, 3, MY_COLL_CMP_CONV))
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1052
    return;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1053

serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
1054
  /*
1055
    Make a special ease of compare with date/time and longlong fields.
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
1056 1057 1058
    They are compared as integers, so for const item this time-consuming
    conversion can be done only once, not for every single comparison
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1059 1060 1061
  if (args[0]->type() == FIELD_ITEM)
  {
    Field *field=((Item_field*) args[0])->field;
1062 1063
    if (!thd->is_context_analysis_only() &&
        field->can_be_compared_as_longlong())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1064
    {
1065 1066 1067 1068
      /*
        The following can't be recoded with || as convert_constant_item
        changes the argument
      */
1069
      if (convert_constant_item(thd, field,&args[1]))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1070
	cmp_type=INT_RESULT;			// Works for all types.
1071
      if (convert_constant_item(thd, field,&args[2]))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1072 1073 1074 1075 1076 1077 1078 1079
	cmp_type=INT_RESULT;			// Works for all types.
    }
  }
}


longlong Item_func_between::val_int()
{						// ANSI BETWEEN
1080
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1081 1082 1083 1084 1085 1086 1087 1088 1089
  if (cmp_type == STRING_RESULT)
  {
    String *value,*a,*b;
    value=args[0]->val_str(&value0);
    if ((null_value=args[0]->null_value))
      return 0;
    a=args[1]->val_str(&value1);
    b=args[2]->val_str(&value2);
    if (!args[1]->null_value && !args[2]->null_value)
aivanov@mysql.com's avatar
aivanov@mysql.com committed
1090 1091 1092
      return (longlong) ((sortcmp(value,a,cmp_collation.collation) >= 0 &&
                          sortcmp(value,b,cmp_collation.collation) <= 0) !=
                         negated);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1093 1094 1095 1096
    if (args[1]->null_value && args[2]->null_value)
      null_value=1;
    else if (args[1]->null_value)
    {
monty@mysql.com's avatar
monty@mysql.com committed
1097 1098
      // Set to not null if false range.
      null_value= sortcmp(value,b,cmp_collation.collation) <= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1099 1100 1101
    }
    else
    {
monty@mysql.com's avatar
monty@mysql.com committed
1102 1103
      // Set to not null if false range.
      null_value= sortcmp(value,a,cmp_collation.collation) >= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1104 1105 1106 1107
    }
  }
  else if (cmp_type == INT_RESULT)
  {
1108
    longlong value=args[0]->val_int(), a, b;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1109
    if ((null_value=args[0]->null_value))
1110
      return 0;					/* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1111 1112 1113
    a=args[1]->val_int();
    b=args[2]->val_int();
    if (!args[1]->null_value && !args[2]->null_value)
aivanov@mysql.com's avatar
aivanov@mysql.com committed
1114
      return (longlong) ((value >= a && value <= b) != negated);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
    if (args[1]->null_value && args[2]->null_value)
      null_value=1;
    else if (args[1]->null_value)
    {
      null_value= value <= b;			// not null if false range.
    }
    else
    {
      null_value= value >= a;
    }
  }
1126 1127 1128 1129 1130 1131 1132 1133 1134
  else if (cmp_type == DECIMAL_RESULT)
  {
    my_decimal dec_buf, *dec= args[0]->val_decimal(&dec_buf),
               a_buf, *a_dec, b_buf, *b_dec;
    if ((null_value=args[0]->null_value))
      return 0;					/* purecov: inspected */
    a_dec= args[1]->val_decimal(&a_buf);
    b_dec= args[2]->val_decimal(&b_buf);
    if (!args[1]->null_value && !args[2]->null_value)
1135 1136
      return (longlong) ((my_decimal_cmp(dec, a_dec) >= 0 &&
                          my_decimal_cmp(dec, b_dec) <= 0) != negated);
1137 1138 1139 1140 1141 1142 1143
    if (args[1]->null_value && args[2]->null_value)
      null_value=1;
    else if (args[1]->null_value)
      null_value= (my_decimal_cmp(dec, b_dec) <= 0);
    else
      null_value= (my_decimal_cmp(dec, a_dec) >= 0);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1144 1145
  else
  {
1146
    double value= args[0]->val_real(),a,b;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1147
    if ((null_value=args[0]->null_value))
1148
      return 0;					/* purecov: inspected */
1149 1150
    a= args[1]->val_real();
    b= args[2]->val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1151
    if (!args[1]->null_value && !args[2]->null_value)
aivanov@mysql.com's avatar
aivanov@mysql.com committed
1152
      return (longlong) ((value >= a && value <= b) != negated);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
    if (args[1]->null_value && args[2]->null_value)
      null_value=1;
    else if (args[1]->null_value)
    {
      null_value= value <= b;			// not null if false range.
    }
    else
    {
      null_value= value >= a;
    }
  }
aivanov@mysql.com's avatar
aivanov@mysql.com committed
1164
  return (longlong) (!null_value && negated);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1165 1166
}

1167 1168 1169 1170 1171

void Item_func_between::print(String *str)
{
  str->append('(');
  args[0]->print(str);
1172 1173
  if (negated)
    str->append(" not", 4);
1174
  str->append(" between ", 9);
1175
  args[1]->print(str);
1176
  str->append(" and ", 5);
1177 1178 1179 1180
  args[2]->print(str);
  str->append(')');
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1181 1182 1183
void
Item_func_ifnull::fix_length_and_dec()
{
1184
  agg_result_type(&hybrid_type, args, 2);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1185
  maybe_null=args[1]->maybe_null;
1186
  decimals= max(args[0]->decimals, args[1]->decimals);
1187 1188 1189 1190 1191
  max_length= (hybrid_type == DECIMAL_RESULT || hybrid_type == INT_RESULT) ?
    (max(args[0]->max_length - args[0]->decimals,
         args[1]->max_length - args[1]->decimals) + decimals) :
    max(args[0]->max_length, args[1]->max_length);

1192
  switch (hybrid_type) {
1193
  case STRING_RESULT:
bar@mysql.com's avatar
bar@mysql.com committed
1194
    agg_arg_charsets(collation, args, arg_count, MY_COLL_CMP_CONV);
1195 1196 1197 1198 1199
    break;
  case DECIMAL_RESULT:
  case REAL_RESULT:
    break;
  case INT_RESULT:
1200
    decimals= 0;
1201 1202 1203 1204 1205
    break;
  case ROW_RESULT:
  default:
    DBUG_ASSERT(0);
  }
1206 1207 1208
  cached_field_type= args[0]->field_type();
  if (cached_field_type != args[1]->field_type())
    cached_field_type= Item_func::field_type();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1209 1210
}

1211 1212 1213 1214 1215 1216 1217 1218

uint Item_func_ifnull::decimal_precision() const
{
  int max_int_part=max(args[0]->decimal_int_part(),args[1]->decimal_int_part());
  return min(max_int_part + decimals, DECIMAL_MAX_PRECISION);
}


1219 1220 1221
enum_field_types Item_func_ifnull::field_type() const 
{
  return cached_field_type;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1222 1223
}

1224 1225 1226 1227
Field *Item_func_ifnull::tmp_table_field(TABLE *table)
{
  return tmp_table_field_from_field_type(table);
}
1228

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1229
double
1230
Item_func_ifnull::real_op()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1231
{
1232
  DBUG_ASSERT(fixed == 1);
1233
  double value= args[0]->val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1234 1235 1236 1237 1238
  if (!args[0]->null_value)
  {
    null_value=0;
    return value;
  }
1239
  value= args[1]->val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1240 1241 1242 1243 1244 1245
  if ((null_value=args[1]->null_value))
    return 0.0;
  return value;
}

longlong
1246
Item_func_ifnull::int_op()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1247
{
1248
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260
  longlong value=args[0]->val_int();
  if (!args[0]->null_value)
  {
    null_value=0;
    return value;
  }
  value=args[1]->val_int();
  if ((null_value=args[1]->null_value))
    return 0;
  return value;
}

1261

1262
my_decimal *Item_func_ifnull::decimal_op(my_decimal *decimal_value)
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
{
  DBUG_ASSERT(fixed == 1);
  my_decimal *value= args[0]->val_decimal(decimal_value);
  if (!args[0]->null_value)
  {
    null_value= 0;
    return value;
  }
  value= args[1]->val_decimal(decimal_value);
  if ((null_value= args[1]->null_value))
    return 0;
  return value;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1278
String *
1279
Item_func_ifnull::str_op(String *str)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1280
{
1281
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1282 1283 1284 1285
  String *res  =args[0]->val_str(str);
  if (!args[0]->null_value)
  {
    null_value=0;
1286
    res->set_charset(collation.collation);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1287 1288 1289 1290 1291
    return res;
  }
  res=args[1]->val_str(str);
  if ((null_value=args[1]->null_value))
    return 0;
1292
  res->set_charset(collation.collation);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1293 1294 1295
  return res;
}

1296

aivanov@mysql.com's avatar
aivanov@mysql.com committed
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324
/*
  Perform context analysis of an IF item tree

  SYNOPSIS:
    fix_fields()
    thd     reference to the global context of the query thread
    tables  list of all open tables involved in the query
    ref     pointer to Item* variable where pointer to resulting "fixed"
            item is to be assigned

  DESCRIPTION
    This function performs context analysis (name resolution) and calculates
    various attributes of the item tree with Item_func_if as its root.
    The function saves in ref the pointer to the item or to a newly created
    item that is considered as a replacement for the original one.

  NOTES
    Let T0(e)/T1(e) be the value of not_null_tables(e) when e is used on
    a predicate/function level. Then it's easy to show that:
      T0(IF(e,e1,e2)  = T1(IF(e,e1,e2))
      T1(IF(e,e1,e2)) = intersection(T1(e1),T1(e2))

  RETURN
    0   ok
    1   got error
*/

bool
1325
Item_func_if::fix_fields(THD *thd, Item **ref)
aivanov@mysql.com's avatar
aivanov@mysql.com committed
1326 1327 1328 1329
{
  DBUG_ASSERT(fixed == 0);
  args[0]->top_level_item();

1330
  if (Item_func::fix_fields(thd, ref))
aivanov@mysql.com's avatar
aivanov@mysql.com committed
1331 1332
    return 1;

1333 1334
  not_null_tables_cache= (args[1]->not_null_tables() &
                          args[2]->not_null_tables());
aivanov@mysql.com's avatar
aivanov@mysql.com committed
1335 1336 1337 1338 1339

  return 0;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1340 1341 1342 1343
void
Item_func_if::fix_length_and_dec()
{
  maybe_null=args[1]->maybe_null || args[2]->maybe_null;
1344
  decimals= max(args[1]->decimals, args[2]->decimals);
1345

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1346 1347
  enum Item_result arg1_type=args[1]->result_type();
  enum Item_result arg2_type=args[2]->result_type();
1348 1349
  bool null1=args[1]->const_item() && args[1]->null_value;
  bool null2=args[2]->const_item() && args[2]->null_value;
1350 1351 1352 1353

  if (null1)
  {
    cached_result_type= arg2_type;
1354
    collation.set(args[2]->collation.collation);
1355 1356 1357
  }
  else if (null2)
  {
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1358
    cached_result_type= arg1_type;
1359
    collation.set(args[1]->collation.collation);
1360
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1361
  else
1362
  {
1363 1364 1365
    agg_result_type(&cached_result_type, args+1, 2);
    if (cached_result_type == STRING_RESULT)
    {
bar@mysql.com's avatar
bar@mysql.com committed
1366
      if (agg_arg_charsets(collation, args+1, 2, MY_COLL_ALLOW_CONV))
1367
        return;
1368
    }
1369
    else
1370
    {
1371
      collation.set(&my_charset_bin);	// Number
1372
    }
1373
  }
1374 1375 1376 1377 1378
  max_length=
    (cached_result_type == DECIMAL_RESULT || cached_result_type == INT_RESULT) ?
    (max(args[1]->max_length - args[1]->decimals,
         args[2]->max_length - args[2]->decimals) + decimals) :
    max(args[1]->max_length, args[2]->max_length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1379 1380 1381
}


1382 1383 1384 1385 1386 1387 1388 1389
uint Item_func_if::decimal_precision() const
{
  int precision=(max(args[1]->decimal_int_part(),args[2]->decimal_int_part())+
                 decimals);
  return min(precision, DECIMAL_MAX_PRECISION);
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1390
double
1391
Item_func_if::val_real()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1392
{
1393
  DBUG_ASSERT(fixed == 1);
1394
  Item *arg= args[0]->val_bool() ? args[1] : args[2];
1395
  double value= arg->val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1396 1397 1398 1399 1400 1401 1402
  null_value=arg->null_value;
  return value;
}

longlong
Item_func_if::val_int()
{
1403
  DBUG_ASSERT(fixed == 1);
1404
  Item *arg= args[0]->val_bool() ? args[1] : args[2];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1405 1406 1407 1408 1409 1410 1411 1412
  longlong value=arg->val_int();
  null_value=arg->null_value;
  return value;
}

String *
Item_func_if::val_str(String *str)
{
1413
  DBUG_ASSERT(fixed == 1);
1414
  Item *arg= args[0]->val_bool() ? args[1] : args[2];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1415
  String *res=arg->val_str(str);
1416
  if (res)
1417
    res->set_charset(collation.collation);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1418 1419 1420 1421 1422
  null_value=arg->null_value;
  return res;
}


1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433
my_decimal *
Item_func_if::val_decimal(my_decimal *decimal_value)
{
  DBUG_ASSERT(fixed == 1);
  Item *arg= args[0]->val_bool() ? args[1] : args[2];
  my_decimal *value= arg->val_decimal(decimal_value);
  null_value= arg->null_value;
  return value;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1434 1435 1436 1437 1438 1439 1440 1441 1442
void
Item_func_nullif::fix_length_and_dec()
{
  Item_bool_func2::fix_length_and_dec();
  maybe_null=1;
  if (args[0])					// Only false if EOM
  {
    max_length=args[0]->max_length;
    decimals=args[0]->decimals;
1443 1444
    unsigned_flag= args[0]->unsigned_flag;
    cached_result_type= args[0]->result_type();
1445 1446 1447
    if (cached_result_type == STRING_RESULT &&
        agg_arg_charsets(collation, args, arg_count, MY_COLL_CMP_CONV))
      return;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1448 1449 1450
  }
}

1451

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1452
/*
1453
  nullif () returns NULL if arguments are equal, else it returns the
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1454 1455 1456 1457 1458 1459
  first argument.
  Note that we have to evaluate the first argument twice as the compare
  may have been done with a different type than return value
*/

double
1460
Item_func_nullif::val_real()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1461
{
1462
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1463
  double value;
monty@mysql.com's avatar
monty@mysql.com committed
1464
  if (!cmp.compare())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1465 1466 1467 1468
  {
    null_value=1;
    return 0.0;
  }
1469
  value= args[0]->val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1470 1471 1472 1473 1474 1475 1476
  null_value=args[0]->null_value;
  return value;
}

longlong
Item_func_nullif::val_int()
{
1477
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1478
  longlong value;
monty@mysql.com's avatar
monty@mysql.com committed
1479
  if (!cmp.compare())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491
  {
    null_value=1;
    return 0;
  }
  value=args[0]->val_int();
  null_value=args[0]->null_value;
  return value;
}

String *
Item_func_nullif::val_str(String *str)
{
1492
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1493
  String *res;
monty@mysql.com's avatar
monty@mysql.com committed
1494
  if (!cmp.compare())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1495 1496 1497 1498 1499 1500 1501 1502 1503
  {
    null_value=1;
    return 0;
  }
  res=args[0]->val_str(str);
  null_value=args[0]->null_value;
  return res;
}

1504

1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
my_decimal *
Item_func_nullif::val_decimal(my_decimal * decimal_value)
{
  DBUG_ASSERT(fixed == 1);
  my_decimal *res;
  if (!cmp.compare())
  {
    null_value=1;
    return 0;
  }
  res= args[0]->val_decimal(decimal_value);
  null_value= args[0]->null_value;
  return res;
}


1521 1522 1523
bool
Item_func_nullif::is_null()
{
1524
  return (null_value= (!cmp.compare() ? 1 : args[0]->null_value)); 
1525 1526
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1527
/*
1528 1529
  CASE expression 
  Return the matching ITEM or NULL if all compares (including else) failed
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1530 1531 1532 1533
*/

Item *Item_func_case::find_item(String *str)
{
1534 1535
  String *first_expr_str, *tmp;
  my_decimal *first_expr_dec, first_expr_dec_val;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1536 1537
  longlong first_expr_int;
  double   first_expr_real;
1538 1539
  char buff[MAX_FIELD_WIDTH];
  String buff_str(buff,sizeof(buff),default_charset());
1540

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1541 1542 1543 1544
  /* These will be initialized later */
  LINT_INIT(first_expr_str);
  LINT_INIT(first_expr_int);
  LINT_INIT(first_expr_real);
1545
  LINT_INIT(first_expr_dec);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1546

bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1547 1548 1549 1550 1551 1552
  if (first_expr_num != -1)
  {
    switch (cmp_type)
    {
      case STRING_RESULT:
      	// We can't use 'str' here as this may be overwritten
1553
	if (!(first_expr_str= args[first_expr_num]->val_str(&buff_str)))
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1554 1555 1556 1557 1558 1559 1560 1561
	  return else_expr_num != -1 ? args[else_expr_num] : 0;	// Impossible
        break;
      case INT_RESULT:
	first_expr_int= args[first_expr_num]->val_int();
	if (args[first_expr_num]->null_value)
	  return else_expr_num != -1 ? args[else_expr_num] : 0;
	break;
      case REAL_RESULT:
1562
	first_expr_real= args[first_expr_num]->val_real();
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1563 1564 1565
	if (args[first_expr_num]->null_value)
	  return else_expr_num != -1 ? args[else_expr_num] : 0;
	break;
1566 1567 1568 1569 1570
      case DECIMAL_RESULT:
        first_expr_dec= args[first_expr_num]->val_decimal(&first_expr_dec_val);
        if (args[first_expr_num]->null_value)
          return else_expr_num != -1 ? args[else_expr_num] : 0;
        break;
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1571 1572
      case ROW_RESULT:
      default:
1573
        // This case should never be chosen
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1574 1575 1576 1577 1578
	DBUG_ASSERT(0);
	break;
    }
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1579
  // Compare every WHEN argument with it and return the first match
1580
  for (uint i=0 ; i < ncases ; i+=2)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1581
  {
1582
    if (first_expr_num == -1)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1583
    {
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1584
      // No expression between CASE and the first WHEN
1585
      if (args[i]->val_bool())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1586 1587 1588
	return args[i+1];
      continue;
    }
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1589
    switch (cmp_type) {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1590 1591
    case STRING_RESULT:
      if ((tmp=args[i]->val_str(str)))		// If not null
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1592
	if (sortcmp(tmp,first_expr_str,cmp_collation.collation)==0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1593 1594 1595 1596 1597 1598 1599
	  return args[i+1];
      break;
    case INT_RESULT:
      if (args[i]->val_int()==first_expr_int && !args[i]->null_value) 
        return args[i+1];
      break;
    case REAL_RESULT: 
1600
      if (args[i]->val_real() == first_expr_real && !args[i]->null_value)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1601
        return args[i+1];
1602
      break;
1603 1604 1605 1606 1607 1608 1609
    case DECIMAL_RESULT:
    {
      my_decimal value;
      if (my_decimal_cmp(args[i]->val_decimal(&value), first_expr_dec) == 0)
        return args[i+1];
      break;
    }
1610
    case ROW_RESULT:
1611
    default:
1612
      // This case should never be chosen
1613 1614
      DBUG_ASSERT(0);
      break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1615 1616 1617
    }
  }
  // No, WHEN clauses all missed, return ELSE expression
1618
  return else_expr_num != -1 ? args[else_expr_num] : 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1619 1620 1621 1622 1623
}


String *Item_func_case::val_str(String *str)
{
1624
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1625 1626 1627 1628 1629 1630 1631 1632
  String *res;
  Item *item=find_item(str);

  if (!item)
  {
    null_value=1;
    return 0;
  }
1633
  null_value= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1634
  if (!(res=item->val_str(str)))
1635
    null_value= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1636 1637 1638 1639 1640 1641
  return res;
}


longlong Item_func_case::val_int()
{
1642
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1643
  char buff[MAX_FIELD_WIDTH];
1644
  String dummy_str(buff,sizeof(buff),default_charset());
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657
  Item *item=find_item(&dummy_str);
  longlong res;

  if (!item)
  {
    null_value=1;
    return 0;
  }
  res=item->val_int();
  null_value=item->null_value;
  return res;
}

1658
double Item_func_case::val_real()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1659
{
1660
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1661
  char buff[MAX_FIELD_WIDTH];
1662
  String dummy_str(buff,sizeof(buff),default_charset());
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1663 1664 1665 1666 1667 1668 1669 1670
  Item *item=find_item(&dummy_str);
  double res;

  if (!item)
  {
    null_value=1;
    return 0;
  }
1671
  res= item->val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1672 1673 1674 1675
  null_value=item->null_value;
  return res;
}

1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696

my_decimal *Item_func_case::val_decimal(my_decimal *decimal_value)
{
  DBUG_ASSERT(fixed == 1);
  char buff[MAX_FIELD_WIDTH];
  String dummy_str(buff, sizeof(buff), default_charset());
  Item *item= find_item(&dummy_str);
  my_decimal *res;

  if (!item)
  {
    null_value=1;
    return 0;
  }

  res= item->val_decimal(decimal_value);
  null_value= item->null_value;
  return res;
}


monty@mysql.com's avatar
monty@mysql.com committed
1697
bool Item_func_case::fix_fields(THD *thd, Item **ref)
1698 1699 1700 1701 1702 1703
{
  /*
    buff should match stack usage from
    Item_func_case::val_int() -> Item_func_case::find_item()
  */
  char buff[MAX_FIELD_WIDTH*2+sizeof(String)*2+sizeof(String*)*2+sizeof(double)*2+sizeof(longlong)*2];
monty@mysql.com's avatar
monty@mysql.com committed
1704 1705 1706 1707 1708
  bool res= Item_func::fix_fields(thd, ref);
  /*
    Call check_stack_overrun after fix_fields to be sure that stack variable
    is not optimized away
  */
1709 1710
  if (check_stack_overrun(thd, STACK_MIN_SIZE, buff))
    return TRUE;				// Fatal error flag is set!
monty@mysql.com's avatar
monty@mysql.com committed
1711
  return res;
1712 1713 1714 1715
}



bk@work.mysql.com's avatar
bk@work.mysql.com committed
1716
void Item_func_case::fix_length_and_dec()
1717
{
1718 1719 1720 1721 1722 1723
  Item **agg;
  uint nagg;
  
  if (!(agg= (Item**) sql_alloc(sizeof(Item*)*(ncases+1))))
    return;
  
1724 1725 1726 1727
  /*
    Aggregate all THEN and ELSE expression types
    and collations when string result
  */
1728 1729 1730 1731 1732 1733 1734 1735 1736
  
  for (nagg= 0 ; nagg < ncases/2 ; nagg++)
    agg[nagg]= args[nagg*2+1];
  
  if (else_expr_num != -1)
    agg[nagg++]= args[else_expr_num];
  
  agg_result_type(&cached_result_type, agg, nagg);
  if ((cached_result_type == STRING_RESULT) &&
bar@mysql.com's avatar
bar@mysql.com committed
1737
      agg_arg_charsets(collation, agg, nagg, MY_COLL_ALLOW_CONV))
1738 1739 1740
    return;
  
  
1741 1742 1743 1744
  /*
    Aggregate first expression and all THEN expression types
    and collations when string comparison
  */
1745
  if (first_expr_num != -1)
1746
  {
1747 1748
    agg[0]= args[first_expr_num];
    for (nagg= 0; nagg < ncases/2 ; nagg++)
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1749
      agg[nagg+1]= args[nagg*2];
1750 1751 1752
    nagg++;
    agg_cmp_type(&cmp_type, agg, nagg);
    if ((cmp_type == STRING_RESULT) &&
bar@mysql.com's avatar
bar@mysql.com committed
1753
        agg_arg_charsets(cmp_collation, agg, nagg, MY_COLL_CMP_CONV))
1754
      return;
1755
  }
1756
  
1757
  if (else_expr_num == -1 || args[else_expr_num]->maybe_null)
1758
    maybe_null=1;
1759
  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1760 1761
  max_length=0;
  decimals=0;
1762
  for (uint i=0 ; i < ncases ; i+=2)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1763 1764 1765 1766
  {
    set_if_bigger(max_length,args[i+1]->max_length);
    set_if_bigger(decimals,args[i+1]->decimals);
  }
1767
  if (else_expr_num != -1) 
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1768
  {
1769 1770
    set_if_bigger(max_length,args[else_expr_num]->max_length);
    set_if_bigger(decimals,args[else_expr_num]->decimals);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1771 1772 1773
  }
}

1774

1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786
uint Item_func_case::decimal_precision() const
{
  int max_int_part=0;
  for (uint i=0 ; i < ncases ; i+=2)
    set_if_bigger(max_int_part, args[i+1]->decimal_int_part());

  if (else_expr_num != -1) 
    set_if_bigger(max_int_part, args[else_expr_num]->decimal_int_part());
  return min(max_int_part + decimals, DECIMAL_MAX_PRECISION);
}


1787
/* TODO:  Fix this so that it prints the whole CASE expression */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1788 1789 1790

void Item_func_case::print(String *str)
{
1791
  str->append("(case ", 6);
1792 1793 1794 1795 1796 1797 1798
  if (first_expr_num != -1)
  {
    args[first_expr_num]->print(str);
    str->append(' ');
  }
  for (uint i=0 ; i < ncases ; i+=2)
  {
1799
    str->append("when ", 5);
1800
    args[i]->print(str);
1801
    str->append(" then ", 6);
1802 1803 1804 1805 1806
    args[i+1]->print(str);
    str->append(' ');
  }
  if (else_expr_num != -1)
  {
1807
    str->append("else ", 5);
1808 1809 1810
    args[else_expr_num]->print(str);
    str->append(' ');
  }
1811
  str->append("end)", 4);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1812 1813 1814
}

/*
1815
  Coalesce - return first not NULL argument.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1816 1817
*/

1818
String *Item_func_coalesce::str_op(String *str)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1819
{
1820
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1821 1822 1823
  null_value=0;
  for (uint i=0 ; i < arg_count ; i++)
  {
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1824 1825 1826
    String *res;
    if ((res=args[i]->val_str(str)))
      return res;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1827 1828 1829 1830 1831
  }
  null_value=1;
  return 0;
}

1832
longlong Item_func_coalesce::int_op()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1833
{
1834
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845
  null_value=0;
  for (uint i=0 ; i < arg_count ; i++)
  {
    longlong res=args[i]->val_int();
    if (!args[i]->null_value)
      return res;
  }
  null_value=1;
  return 0;
}

1846
double Item_func_coalesce::real_op()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1847
{
1848
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1849 1850 1851
  null_value=0;
  for (uint i=0 ; i < arg_count ; i++)
  {
1852
    double res= args[i]->val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1853 1854 1855 1856 1857 1858 1859 1860
    if (!args[i]->null_value)
      return res;
  }
  null_value=1;
  return 0;
}


1861
my_decimal *Item_func_coalesce::decimal_op(my_decimal *decimal_value)
1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875
{
  DBUG_ASSERT(fixed == 1);
  null_value= 0;
  for (uint i= 0; i < arg_count; i++)
  {
    my_decimal *res= args[i]->val_decimal(decimal_value);
    if (!args[i]->null_value)
      return res;
  }
  null_value=1;
  return 0;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1876 1877
void Item_func_coalesce::fix_length_and_dec()
{
1878 1879
  agg_result_type(&hybrid_type, args, arg_count);
  switch (hybrid_type) {
1880 1881 1882
  case STRING_RESULT:
    count_only_length();
    decimals= NOT_FIXED_DEC;
bar@mysql.com's avatar
bar@mysql.com committed
1883
    agg_arg_charsets(collation, args, arg_count, MY_COLL_ALLOW_CONV);
1884 1885 1886 1887 1888 1889 1890 1891 1892
    break;
  case DECIMAL_RESULT:
    count_decimal_length();
    break;
  case REAL_RESULT:
    count_real_length();
    break;
  case INT_RESULT:
    count_only_length();
1893
    decimals= 0;
1894 1895
    break;
  case ROW_RESULT:
1896
  default:
1897 1898
    DBUG_ASSERT(0);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1899 1900 1901
}

/****************************************************************************
1902
 Classes and function for the IN operator
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1903 1904
****************************************************************************/

1905
static int cmp_longlong(void *cmp_arg, longlong *a,longlong *b)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1906 1907 1908 1909
{
  return *a < *b ? -1 : *a == *b ? 0 : 1;
}

1910
static int cmp_double(void *cmp_arg, double *a,double *b)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1911 1912 1913 1914
{
  return *a < *b ? -1 : *a == *b ? 0 : 1;
}

1915
static int cmp_row(void *cmp_arg, cmp_item_row *a, cmp_item_row *b)
1916 1917 1918 1919
{
  return a->compare(b);
}

1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932

static int cmp_decimal(void *cmp_arg, my_decimal *a, my_decimal *b)
{
  /*
    We need call of fixing buffer pointer, because fast sort just copy
    decimal buffers in memory and pointers left pointing on old buffer place
  */
  a->fix_buffer_pointer();
  b->fix_buffer_pointer();
  return my_decimal_cmp(a, b);
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
int in_vector::find(Item *item)
{
  byte *result=get_value(item);
  if (!result || !used_count)
    return 0;				// Null value

  uint start,end;
  start=0; end=used_count-1;
  while (start != end)
  {
    uint mid=(start+end+1)/2;
    int res;
1945
    if ((res=(*compare)(collation, base+mid*size, result)) == 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1946 1947 1948 1949 1950 1951
      return 1;
    if (res < 0)
      start=mid;
    else
      end=mid-1;
  }
1952
  return (int) ((*compare)(collation, base+start*size, result) == 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1953 1954
}

1955 1956
in_string::in_string(uint elements,qsort2_cmp cmp_func, CHARSET_INFO *cs)
  :in_vector(elements, sizeof(String), cmp_func, cs),
1957
   tmp(buff, sizeof(buff), &my_charset_bin)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1958 1959 1960 1961
{}

in_string::~in_string()
{
1962
  if (base)
1963
  {
1964
    // base was allocated with help of sql_alloc => following is OK
1965 1966
    for (uint i=0 ; i < count ; i++)
      ((String*) base)[i].free();
1967
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1968 1969 1970 1971 1972 1973 1974
}

void in_string::set(uint pos,Item *item)
{
  String *str=((String*) base)+pos;
  String *res=item->val_str(str);
  if (res && res != str)
1975 1976 1977
  {
    if (res->uses_buffer_owned_by(str))
      res->copy();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1978
    *str= *res;
1979
  }
1980
  if (!str->charset())
1981 1982
  {
    CHARSET_INFO *cs;
1983
    if (!(cs= item->collation.collation))
1984
      cs= &my_charset_bin;		// Should never happen for STR items
1985 1986
    str->set_charset(cs);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1987 1988
}

1989

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1990 1991 1992 1993 1994
byte *in_string::get_value(Item *item)
{
  return (byte*) item->val_str(&tmp);
}

1995 1996
in_row::in_row(uint elements, Item * item)
{
1997
  base= (char*) new cmp_item_row[count= elements];
1998
  size= sizeof(cmp_item_row);
1999
  compare= (qsort2_cmp) cmp_row;
2000
  tmp.store_value(item);
2001 2002 2003 2004 2005 2006
  /*
    We need to reset these as otherwise we will call sort() with
    uninitialized (even if not used) elements
  */
  used_count= elements;
  collation= 0;
2007 2008 2009 2010 2011
}

in_row::~in_row()
{
  if (base)
2012
    delete [] (cmp_item_row*) base;
2013 2014 2015 2016 2017
}

byte *in_row::get_value(Item *item)
{
  tmp.store_value(item);
2018 2019
  if (item->is_null())
    return 0;
2020 2021 2022 2023 2024 2025 2026 2027 2028 2029
  return (byte *)&tmp;
}

void in_row::set(uint pos, Item *item)
{
  DBUG_ENTER("in_row::set");
  DBUG_PRINT("enter", ("pos %u item 0x%lx", pos, (ulong) item));
  ((cmp_item_row*) base)[pos].store_value_by_template(&tmp, item);
  DBUG_VOID_RETURN;
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2030 2031

in_longlong::in_longlong(uint elements)
2032
  :in_vector(elements,sizeof(longlong),(qsort2_cmp) cmp_longlong, 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2033 2034 2035 2036 2037 2038 2039 2040 2041
{}

void in_longlong::set(uint pos,Item *item)
{
  ((longlong*) base)[pos]=item->val_int();
}

byte *in_longlong::get_value(Item *item)
{
2042
  tmp= item->val_int();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2043
  if (item->null_value)
2044
    return 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2045 2046 2047 2048
  return (byte*) &tmp;
}

in_double::in_double(uint elements)
2049
  :in_vector(elements,sizeof(double),(qsort2_cmp) cmp_double, 0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2050 2051 2052 2053
{}

void in_double::set(uint pos,Item *item)
{
2054
  ((double*) base)[pos]= item->val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2055 2056 2057 2058
}

byte *in_double::get_value(Item *item)
{
2059
  tmp= item->val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2060
  if (item->null_value)
2061
    return 0;					/* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2062 2063 2064
  return (byte*) &tmp;
}

2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093

in_decimal::in_decimal(uint elements)
  :in_vector(elements, sizeof(my_decimal),(qsort2_cmp) cmp_decimal, 0)
{}


void in_decimal::set(uint pos, Item *item)
{
  /* as far as 'item' is constant, we can store reference on my_decimal */
  my_decimal *dec= ((my_decimal *)base) + pos;
  dec->len= DECIMAL_BUFF_LENGTH;
  dec->fix_buffer_pointer();
  my_decimal *res= item->val_decimal(dec);
  if (res != dec)
    my_decimal2decimal(res, dec);
}


byte *in_decimal::get_value(Item *item)
{
  my_decimal *result= item->val_decimal(&val);
  if (item->null_value)
    return 0;
  return (byte *)result;
}


cmp_item* cmp_item::get_comparator(Item_result type,
                                   CHARSET_INFO *cs)
2094
{
2095
  switch (type) {
2096
  case STRING_RESULT:
2097
    return new cmp_item_sort_string(cs);
2098 2099 2100 2101 2102 2103
  case INT_RESULT:
    return new cmp_item_int;
  case REAL_RESULT:
    return new cmp_item_real;
  case ROW_RESULT:
    return new cmp_item_row;
2104 2105
  case DECIMAL_RESULT:
    return new cmp_item_decimal;
2106 2107 2108
  default:
    DBUG_ASSERT(0);
    break;
2109 2110 2111 2112
  }
  return 0; // to satisfy compiler :)
}

2113

2114 2115
cmp_item* cmp_item_sort_string::make_same()
{
2116
  return new cmp_item_sort_string_in_static(cmp_charset);
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133
}

cmp_item* cmp_item_int::make_same()
{
  return new cmp_item_int();
}

cmp_item* cmp_item_real::make_same()
{
  return new cmp_item_real();
}

cmp_item* cmp_item_row::make_same()
{
  return new cmp_item_row();
}

2134 2135 2136 2137

cmp_item_row::~cmp_item_row()
{
  DBUG_ENTER("~cmp_item_row");
2138
  DBUG_PRINT("enter",("this: 0x%lx", this));
2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
  if (comparators)
  {
    for (uint i= 0; i < n; i++)
    {
      if (comparators[i])
	delete comparators[i];
    }
  }
  DBUG_VOID_RETURN;
}


2151 2152
void cmp_item_row::store_value(Item *item)
{
2153
  DBUG_ENTER("cmp_item_row::store_value");
2154
  n= item->cols();
2155
  if (!comparators)
2156
    comparators= (cmp_item **) current_thd->calloc(sizeof(cmp_item *)*n);
2157
  if (comparators)
2158
  {
2159
    item->bring_value();
2160
    item->null_value= 0;
2161
    for (uint i=0; i < n; i++)
2162
    {
2163
      if (!comparators[i])
2164 2165 2166
        if (!(comparators[i]=
              cmp_item::get_comparator(item->el(i)->result_type(),
                                       item->el(i)->collation.collation)))
2167
	  break;					// new failed
2168 2169 2170
      comparators[i]->store_value(item->el(i));
      item->null_value|= item->el(i)->null_value;
    }
2171
  }
2172
  DBUG_VOID_RETURN;
2173 2174
}

2175

2176 2177 2178 2179 2180
void cmp_item_row::store_value_by_template(cmp_item *t, Item *item)
{
  cmp_item_row *tmpl= (cmp_item_row*) t;
  if (tmpl->n != item->cols())
  {
2181
    my_error(ER_OPERAND_COLUMNS, MYF(0), tmpl->n);
2182 2183 2184 2185 2186
    return;
  }
  n= tmpl->n;
  if ((comparators= (cmp_item **) sql_alloc(sizeof(cmp_item *)*n)))
  {
2187
    item->bring_value();
2188 2189
    item->null_value= 0;
    for (uint i=0; i < n; i++)
2190 2191 2192 2193 2194 2195 2196
    {
      if (!(comparators[i]= tmpl->comparators[i]->make_same()))
	break;					// new failed
      comparators[i]->store_value_by_template(tmpl->comparators[i],
					      item->el(i));
      item->null_value|= item->el(i)->null_value;
    }
2197 2198 2199
  }
}

2200

2201 2202
int cmp_item_row::cmp(Item *arg)
{
2203 2204 2205
  arg->null_value= 0;
  if (arg->cols() != n)
  {
2206
    my_error(ER_OPERAND_COLUMNS, MYF(0), n);
2207 2208
    return 1;
  }
2209
  bool was_null= 0;
2210
  arg->bring_value();
2211
  for (uint i=0; i < n; i++)
2212
  {
2213
    if (comparators[i]->cmp(arg->el(i)))
2214
    {
2215 2216 2217
      if (!arg->el(i)->null_value)
	return 1;
      was_null= 1;
2218
    }
2219
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2220
  return (arg->null_value= was_null);
2221 2222
}

2223

2224 2225 2226
int cmp_item_row::compare(cmp_item *c)
{
  cmp_item_row *cmp= (cmp_item_row *) c;
2227
  for (uint i=0; i < n; i++)
2228 2229
  {
    int res;
2230
    if ((res= comparators[i]->compare(cmp->comparators[i])))
2231
      return res;
2232
  }
2233 2234
  return 0;
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2235

2236

2237 2238 2239
void cmp_item_decimal::store_value(Item *item)
{
  my_decimal *val= item->val_decimal(&value);
monty@mysql.com's avatar
monty@mysql.com committed
2240 2241
  /* val may be zero if item is nnull */
  if (val && val != &value)
2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254
    my_decimal2decimal(val, &value);
}


int cmp_item_decimal::cmp(Item *arg)
{
  my_decimal tmp_buf, *tmp= arg->val_decimal(&tmp_buf);
  if (arg->null_value)
    return 1;
  return my_decimal_cmp(&value, tmp);
}


monty@mysql.com's avatar
monty@mysql.com committed
2255
int cmp_item_decimal::compare(cmp_item *arg)
2256
{
monty@mysql.com's avatar
monty@mysql.com committed
2257
  cmp_item_decimal *cmp= (cmp_item_decimal*) arg;
2258 2259 2260 2261 2262 2263 2264 2265 2266 2267
  return my_decimal_cmp(&value, &cmp->value);
}


cmp_item* cmp_item_decimal::make_same()
{
  return new cmp_item_decimal();
}


2268 2269 2270
bool Item_func_in::nulls_in_row()
{
  Item **arg,**arg_end;
2271
  for (arg= args+1, arg_end= args+arg_count; arg != arg_end ; arg++)
2272 2273 2274 2275 2276 2277 2278
  {
    if ((*arg)->null_inside())
      return 1;
  }
  return 0;
}

2279

aivanov@mysql.com's avatar
aivanov@mysql.com committed
2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309
/*
  Perform context analysis of an IN item tree

  SYNOPSIS:
    fix_fields()
    thd     reference to the global context of the query thread
    tables  list of all open tables involved in the query
    ref     pointer to Item* variable where pointer to resulting "fixed"
            item is to be assigned

  DESCRIPTION
    This function performs context analysis (name resolution) and calculates
    various attributes of the item tree with Item_func_in as its root.
    The function saves in ref the pointer to the item or to a newly created
    item that is considered as a replacement for the original one.

  NOTES
    Let T0(e)/T1(e) be the value of not_null_tables(e) when e is used on
    a predicate/function level. Then it's easy to show that:
      T0(e IN(e1,...,en))     = union(T1(e),intersection(T1(ei)))
      T1(e IN(e1,...,en))     = union(T1(e),intersection(T1(ei)))
      T0(e NOT IN(e1,...,en)) = union(T1(e),union(T1(ei)))
      T1(e NOT IN(e1,...,en)) = union(T1(e),intersection(T1(ei)))

  RETURN
    0   ok
    1   got error
*/

bool
2310
Item_func_in::fix_fields(THD *thd, Item **ref)
aivanov@mysql.com's avatar
aivanov@mysql.com committed
2311 2312 2313
{
  Item **arg, **arg_end;

2314
  if (Item_func_opt_neg::fix_fields(thd, ref))
aivanov@mysql.com's avatar
aivanov@mysql.com committed
2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329
    return 1;

  /* not_null_tables_cache == union(T1(e),union(T1(ei))) */
  if (pred_level && negated)
    return 0;

  /* not_null_tables_cache = union(T1(e),intersection(T1(ei))) */
  not_null_tables_cache= ~(table_map) 0;
  for (arg= args + 1, arg_end= args + arg_count; arg != arg_end; arg++)
    not_null_tables_cache&= (*arg)->not_null_tables();
  not_null_tables_cache|= (*args)->not_null_tables();
  return 0;
}


2330
static int srtcmp_in(CHARSET_INFO *cs, const String *x,const String *y)
2331
{
2332
  return cs->coll->strnncollsp(cs,
monty@mysql.com's avatar
monty@mysql.com committed
2333
                               (uchar *) x->ptr(),x->length(),
2334
                               (uchar *) y->ptr(),y->length(), 0);
2335 2336
}

2337

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2338 2339
void Item_func_in::fix_length_and_dec()
{
2340 2341
  Item **arg, **arg_end;
  uint const_itm= 1;
2342
  THD *thd= current_thd;
2343
  
2344
  agg_cmp_type(&cmp_type, args, arg_count);
2345

bar@mysql.com's avatar
bar@mysql.com committed
2346 2347 2348 2349
  if (cmp_type == STRING_RESULT &&
      agg_arg_charsets(cmp_collation, args, arg_count, MY_COLL_CMP_CONV))
    return;

2350
  for (arg=args+1, arg_end=args+arg_count; arg != arg_end ; arg++)
monty@mishka.local's avatar
monty@mishka.local committed
2351 2352 2353 2354 2355 2356 2357
  {
    if (!arg[0]->const_item())
    {
      const_itm= 0;
      break;
    }
  }
2358

2359 2360 2361 2362
  /*
    Row item with NULLs inside can return NULL or FALSE => 
    they can't be processed as static
  */
2363
  if (const_itm && !nulls_in_row())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2364
  {
2365
    switch (cmp_type) {
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2366
    case STRING_RESULT:
2367
      array=new in_string(arg_count-1,(qsort2_cmp) srtcmp_in, 
2368
			  cmp_collation.collation);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2369 2370
      break;
    case INT_RESULT:
2371
      array= new in_longlong(arg_count-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2372 2373
      break;
    case REAL_RESULT:
2374
      array= new in_double(arg_count-1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2375
      break;
2376
    case ROW_RESULT:
2377
      array= new in_row(arg_count-1, args[0]);
2378
      break;
2379 2380 2381
    case DECIMAL_RESULT:
      array= new in_decimal(arg_count - 1);
      break;
2382 2383 2384
    default:
      DBUG_ASSERT(0);
      return;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2385
    }
2386
    if (array && !(thd->is_fatal_error))		// If not EOM
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2387
    {
2388
      uint j=0;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2389
      for (uint i=1 ; i < arg_count ; i++)
2390 2391 2392 2393
      {
	array->set(j,args[i]);
	if (!args[i]->null_value)			// Skip NULL values
	  j++;
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
2394 2395
	else
	  have_null= 1;
2396 2397 2398
      }
      if ((array->used_count=j))
	array->sort();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2399 2400 2401 2402
    }
  }
  else
  {
2403
    in_item= cmp_item::get_comparator(cmp_type, cmp_collation.collation);
2404
    if (cmp_type  == STRING_RESULT)
2405
      in_item->cmp_charset= cmp_collation.collation;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2406
  }
2407
  maybe_null= args[0]->maybe_null;
2408
  max_length= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2409 2410 2411 2412 2413 2414
}


void Item_func_in::print(String *str)
{
  str->append('(');
2415
  args[0]->print(str);
2416 2417
  if (negated)
    str->append(" not", 4);
2418
  str->append(" in (", 5);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2419
  print_args(str, 1);
2420
  str->append("))", 2);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2421 2422 2423 2424 2425
}


longlong Item_func_in::val_int()
{
2426
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2427 2428
  if (array)
  {
2429 2430
    int tmp=array->find(args[0]);
    null_value=args[0]->null_value || (!tmp && have_null);
aivanov@mysql.com's avatar
aivanov@mysql.com committed
2431
    return (longlong) (!null_value && tmp != negated);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2432
  }
2433 2434
  in_item->store_value(args[0]);
  if ((null_value=args[0]->null_value))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2435
    return 0;
2436
  have_null= 0;
2437
  for (uint i=1 ; i < arg_count ; i++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2438 2439
  {
    if (!in_item->cmp(args[i]) && !args[i]->null_value)
aivanov@mysql.com's avatar
aivanov@mysql.com committed
2440
      return (longlong) (!negated);
2441
    have_null|= args[i]->null_value;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2442
  }
2443
  null_value= have_null;
aivanov@mysql.com's avatar
aivanov@mysql.com committed
2444
  return (longlong) (!null_value && negated);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2445 2446 2447 2448 2449
}


longlong Item_func_bit_or::val_int()
{
2450
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469
  ulonglong arg1= (ulonglong) args[0]->val_int();
  if (args[0]->null_value)
  {
    null_value=1; /* purecov: inspected */
    return 0; /* purecov: inspected */
  }
  ulonglong arg2= (ulonglong) args[1]->val_int();
  if (args[1]->null_value)
  {
    null_value=1;
    return 0;
  }
  null_value=0;
  return (longlong) (arg1 | arg2);
}


longlong Item_func_bit_and::val_int()
{
2470
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486
  ulonglong arg1= (ulonglong) args[0]->val_int();
  if (args[0]->null_value)
  {
    null_value=1; /* purecov: inspected */
    return 0; /* purecov: inspected */
  }
  ulonglong arg2= (ulonglong) args[1]->val_int();
  if (args[1]->null_value)
  {
    null_value=1; /* purecov: inspected */
    return 0; /* purecov: inspected */
  }
  null_value=0;
  return (longlong) (arg1 & arg2);
}

2487
Item_cond::Item_cond(THD *thd, Item_cond *item)
2488
  :Item_bool_func(thd, item),
2489 2490
   abort_on_null(item->abort_on_null),
   and_tables_cache(item->and_tables_cache)
2491 2492
{
  /*
monty@mysql.com's avatar
monty@mysql.com committed
2493
    item->list will be copied by copy_andor_arguments() call
2494 2495 2496
  */
}

monty@mysql.com's avatar
monty@mysql.com committed
2497

2498 2499 2500
void Item_cond::copy_andor_arguments(THD *thd, Item_cond *item)
{
  List_iterator_fast<Item> li(item->list);
monty@mysql.com's avatar
monty@mysql.com committed
2501
  while (Item *it= li++)
2502 2503
    list.push_back(it->copy_andor_structure(thd));
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2504

monty@mysql.com's avatar
monty@mysql.com committed
2505

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2506
bool
2507
Item_cond::fix_fields(THD *thd, Item **ref)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2508
{
2509
  DBUG_ASSERT(fixed == 0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2510 2511
  List_iterator<Item> li(list);
  Item *item;
2512
#ifndef EMBEDDED_LIBRARY
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2513
  char buff[sizeof(char*)];			// Max local vars in function
2514
#endif
2515
  not_null_tables_cache= used_tables_cache= 0;
2516
  const_item_cache= 1;
2517 2518 2519 2520 2521
  /*
    and_table_cache is the value that Item_cond_or() returns for
    not_null_tables()
  */
  and_tables_cache= ~(table_map) 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2522

2523
  if (check_stack_overrun(thd, STACK_MIN_SIZE, buff))
2524
    return TRUE;				// Fatal error flag is set!
2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539
  /*
    The following optimization reduces the depth of an AND-OR tree.
    E.g. a WHERE clause like
      F1 AND (F2 AND (F2 AND F4))
    is parsed into a tree with the same nested structure as defined
    by braces. This optimization will transform such tree into
      AND (F1, F2, F3, F4).
    Trees of OR items are flattened as well:
      ((F1 OR F2) OR (F3 OR F4))   =>   OR (F1, F2, F3, F4)
    Items for removed AND/OR levels will dangle until the death of the
    entire statement.
    The optimization is currently prepared statements and stored procedures
    friendly as it doesn't allocate any memory and its effects are durable
    (i.e. do not depend on PS/SP arguments).
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2540 2541
  while ((item=li++))
  {
2542
    table_map tmp_table_map;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2543 2544 2545 2546 2547 2548 2549
    while (item->type() == Item::COND_ITEM &&
	   ((Item_cond*) item)->functype() == functype())
    {						// Identical function
      li.replace(((Item_cond*) item)->list);
      ((Item_cond*) item)->list.empty();
      item= *li.ref();				// new current item
    }
2550 2551
    if (abort_on_null)
      item->top_level_item();
2552 2553

    // item can be substituted in fix_fields
2554
    if ((!item->fixed &&
2555
	 item->fix_fields(thd, li.ref())) ||
2556
	(item= *li.ref())->check_cols(1))
2557
      return TRUE; /* purecov: inspected */
2558 2559 2560 2561
    used_tables_cache|=     item->used_tables();
    tmp_table_map=	    item->not_null_tables();
    not_null_tables_cache|= tmp_table_map;
    and_tables_cache&=      tmp_table_map;
2562
    const_item_cache&=      item->const_item();
2563
    with_sum_func=	    with_sum_func || item->with_sum_func;
2564 2565
    if (item->maybe_null)
      maybe_null=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2566
  }
2567
  thd->lex->current_select->cond_count+= list.elements;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2568
  fix_length_and_dec();
2569
  fixed= 1;
2570
  return FALSE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2571 2572
}

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2573 2574 2575 2576 2577 2578 2579 2580 2581 2582
bool Item_cond::walk(Item_processor processor, byte *arg)
{
  List_iterator_fast<Item> li(list);
  Item *item;
  while ((item= li++))
    if (item->walk(processor, arg))
      return 1;
  return Item_func::walk(processor, arg);
}

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594

/*
  Transform an Item_cond object with a transformer callback function
   
  SYNOPSIS
    transform()
    transformer   the transformer callback function to be applied to the nodes
                  of the tree of the object
    arg           parameter to be passed to the transformer
  
  DESCRIPTION
    The function recursively applies the transform method with the
2595
    same transformer to each member item of the condition list.
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2596 2597 2598 2599 2600 2601 2602 2603 2604 2605
    If the call of the method for a member item returns a new item
    the old item is substituted for a new one.
    After this the transform method is applied to the root node
    of the Item_cond object. 
     
  RETURN VALUES
    Item returned as the result of transformation of the root node 
*/

Item *Item_cond::transform(Item_transformer transformer, byte *arg)
2606 2607 2608 2609 2610
{
  List_iterator<Item> li(list);
  Item *item;
  while ((item= li++))
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2611
    Item *new_item= item->transform(transformer, arg);
2612 2613 2614 2615 2616
    if (!new_item)
      return 0;
    if (new_item != item)
      li.replace(new_item);
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2617
  return Item_func::transform(transformer, arg);
2618 2619
}

2620 2621
void Item_cond::traverse_cond(Cond_traverser traverser,
                              void *arg, traverse_order order)
2622 2623 2624 2625
{
  List_iterator<Item> li(list);
  Item *item;

2626 2627 2628 2629 2630 2631 2632
  switch(order) {
  case(PREFIX):
    (*traverser)(this, arg);
    while ((item= li++))
    {
      item->traverse_cond(traverser, arg, order);
    }
2633
    (*traverser)(NULL, arg);
2634 2635 2636 2637 2638 2639 2640
    break;
  case(POSTFIX):
    while ((item= li++))
    {
      item->traverse_cond(traverser, arg, order);
    }
    (*traverser)(this, arg);
2641 2642
  }
}
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2643

2644 2645 2646 2647
/*
  Move SUM items out from item tree and replace with reference

  SYNOPSIS
2648 2649 2650 2651
    split_sum_func()
    thd			Thread handler
    ref_pointer_array	Pointer to array of reference fields
    fields		All fields in select
2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662

  NOTES
   This function is run on all expression (SELECT list, WHERE, HAVING etc)
   that have or refer (HAVING) to a SUM expression.

   The split is done to get an unique item for each SUM function
   so that we can easily find and calculate them.
   (Calculation done by update_sum_func() and copy_sum_funcs() in
   sql_select.cc)
*/

2663 2664
void Item_cond::split_sum_func(THD *thd, Item **ref_pointer_array,
                               List<Item> &fields)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2665 2666 2667
{
  List_iterator<Item> li(list);
  Item *item;
2668 2669
  while ((item= li++))
    item->split_sum_func2(thd, ref_pointer_array, fields, li.ref());
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2670 2671 2672 2673 2674 2675 2676 2677 2678
}


table_map
Item_cond::used_tables() const
{						// This caches used_tables
  return used_tables_cache;
}

2679

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2680 2681
void Item_cond::update_used_tables()
{
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
2682
  List_iterator_fast<Item> li(list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2683
  Item *item;
2684 2685 2686

  used_tables_cache=0;
  const_item_cache=1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2687 2688 2689
  while ((item=li++))
  {
    item->update_used_tables();
2690
    used_tables_cache|= item->used_tables();
2691
    const_item_cache&= item->const_item();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2692 2693 2694 2695 2696 2697 2698
  }
}


void Item_cond::print(String *str)
{
  str->append('(');
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
2699
  List_iterator_fast<Item> li(list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712
  Item *item;
  if ((item=li++))
    item->print(str);
  while ((item=li++))
  {
    str->append(' ');
    str->append(func_name());
    str->append(' ');
    item->print(str);
  }
  str->append(')');
}

2713

2714
void Item_cond::neg_arguments(THD *thd)
2715 2716 2717 2718 2719
{
  List_iterator<Item> li(list);
  Item *item;
  while ((item= li++))		/* Apply not transformation to the arguments */
  {
2720 2721 2722
    Item *new_item= item->neg_transformer(thd);
    if (!new_item)
    {
monty@mysql.com's avatar
monty@mysql.com committed
2723 2724
      if (!(new_item= new Item_func_not(item)))
	return;					// Fatal OEM error
2725 2726
    }
    VOID(li.replace(new_item));
2727 2728 2729 2730
  }
}


2731
/*
2732
  Evaluation of AND(expr, expr, expr ...)
2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747

  NOTES:
    abort_if_null is set for AND expressions for which we don't care if the
    result is NULL or 0. This is set for:
    - WHERE clause
    - HAVING clause
    - IF(expression)

  RETURN VALUES
    1  If all expressions are true
    0  If all expressions are false or if we find a NULL expression and
       'abort_on_null' is set.
    NULL if all expression are either 1 or NULL
*/

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2748 2749 2750

longlong Item_cond_and::val_int()
{
2751
  DBUG_ASSERT(fixed == 1);
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
2752
  List_iterator_fast<Item> li(list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2753
  Item *item;
2754
  null_value= 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2755 2756
  while ((item=li++))
  {
2757
    if (!item->val_bool())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2758
    {
2759 2760
      if (abort_on_null || !(null_value= item->null_value))
	return 0;				// return FALSE
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2761 2762
    }
  }
2763
  return null_value ? 0 : 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2764 2765
}

2766

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2767 2768
longlong Item_cond_or::val_int()
{
2769
  DBUG_ASSERT(fixed == 1);
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
2770
  List_iterator_fast<Item> li(list);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2771 2772 2773 2774
  Item *item;
  null_value=0;
  while ((item=li++))
  {
2775
    if (item->val_bool())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2776 2777 2778 2779 2780 2781 2782 2783 2784 2785
    {
      null_value=0;
      return 1;
    }
    if (item->null_value)
      null_value=1;
  }
  return 0;
}

2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809
/*
  Create an AND expression from two expressions

  SYNOPSIS
   and_expressions()
   a		expression or NULL
   b    	expression.
   org_item	Don't modify a if a == *org_item
		If a == NULL, org_item is set to point at b,
		to ensure that future calls will not modify b.

  NOTES
    This will not modify item pointed to by org_item or b
    The idea is that one can call this in a loop and create and
    'and' over all items without modifying any of the original items.

  RETURN
    NULL	Error
    Item
*/

Item *and_expressions(Item *a, Item *b, Item **org_item)
{
  if (!a)
2810
    return (*org_item= (Item*) b);
2811 2812 2813
  if (a == *org_item)
  {
    Item_cond *res;
2814
    if ((res= new Item_cond_and(a, (Item*) b)))
2815
    {
2816
      res->used_tables_cache= a->used_tables() | b->used_tables();
2817 2818
      res->not_null_tables_cache= a->not_null_tables() | b->not_null_tables();
    }
2819 2820
    return res;
  }
2821
  if (((Item_cond_and*) a)->add((Item*) b))
2822 2823
    return 0;
  ((Item_cond_and*) a)->used_tables_cache|= b->used_tables();
2824
  ((Item_cond_and*) a)->not_null_tables_cache|= b->not_null_tables();
2825 2826 2827 2828
  return a;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
2829 2830
longlong Item_func_isnull::val_int()
{
2831
  DBUG_ASSERT(fixed == 1);
2832 2833 2834 2835 2836
  /*
    Handle optimization if the argument can't be null
    This has to be here because of the test in update_used_tables().
  */
  if (!used_tables_cache)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2837
    return cached_value;
2838
  return args[0]->is_null() ? 1: 0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2839 2840
}

2841 2842
longlong Item_is_not_null_test::val_int()
{
2843
  DBUG_ASSERT(fixed == 1);
2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878
  DBUG_ENTER("Item_is_not_null_test::val_int");
  if (!used_tables_cache)
  {
    owner->was_null|= (!cached_value);
    DBUG_PRINT("info", ("cached :%d", cached_value));
    DBUG_RETURN(cached_value);
  }
  if (args[0]->is_null())
  {
    DBUG_PRINT("info", ("null"))
    owner->was_null|= 1;
    DBUG_RETURN(0);
  }
  else
    DBUG_RETURN(1);
}

/* Optimize case of not_null_column IS NULL */
void Item_is_not_null_test::update_used_tables()
{
  if (!args[0]->maybe_null)
  {
    used_tables_cache= 0;			/* is always true */
    cached_value= (longlong) 1;
  }
  else
  {
    args[0]->update_used_tables();
    if (!(used_tables_cache=args[0]->used_tables()))
    {
      /* Remember if the value is always NULL or never NULL */
      cached_value= (longlong) !args[0]->is_null();
    }
  }
}
2879

2880

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2881 2882
longlong Item_func_isnotnull::val_int()
{
2883
  DBUG_ASSERT(fixed == 1);
2884
  return args[0]->is_null() ? 0 : 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2885 2886 2887
}


2888 2889 2890 2891
void Item_func_isnotnull::print(String *str)
{
  str->append('(');
  args[0]->print(str);
2892
  str->append(" is not null)", 13);
2893 2894 2895
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
2896 2897
longlong Item_func_like::val_int()
{
2898
  DBUG_ASSERT(fixed == 1);
2899
  String* res = args[0]->val_str(&tmp_value1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2900 2901 2902 2903 2904
  if (args[0]->null_value)
  {
    null_value=1;
    return 0;
  }
2905
  String* res2 = args[1]->val_str(&tmp_value2);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2906 2907 2908 2909 2910 2911
  if (args[1]->null_value)
  {
    null_value=1;
    return 0;
  }
  null_value=0;
2912 2913
  if (canDoTurboBM)
    return turboBM_matches(res->ptr(), res->length()) ? 1 : 0;
2914
  return my_wildcmp(cmp.cmp_collation.collation,
2915 2916 2917
		    res->ptr(),res->ptr()+res->length(),
		    res2->ptr(),res2->ptr()+res2->length(),
		    escape,wild_one,wild_many) ? 0 : 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2918 2919 2920 2921 2922 2923 2924
}


/* We can optimize a where if first character isn't a wildcard */

Item_func::optimize_type Item_func_like::select_optimize() const
{
2925
  if (args[1]->const_item())
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2926
  {
2927 2928 2929 2930 2931 2932
    String* res2= args[1]->val_str((String *)&tmp_value2);

    if (!res2)
      return OPTIMIZE_NONE;

    if (*res2->ptr() != wild_many)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2933
    {
2934
      if (args[0]->result_type() != STRING_RESULT || *res2->ptr() != wild_one)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2935 2936 2937 2938 2939 2940
	return OPTIMIZE_OP;
    }
  }
  return OPTIMIZE_NONE;
}

2941

2942
bool Item_func_like::fix_fields(THD *thd, Item **ref)
2943
{
2944
  DBUG_ASSERT(fixed == 0);
2945 2946
  if (Item_bool_func2::fix_fields(thd, ref) ||
      escape_item->fix_fields(thd, &escape_item))
2947
    return TRUE;
2948

2949
  if (!escape_item->const_during_execution())
2950
  {
2951
    my_error(ER_WRONG_ARGUMENTS,MYF(0),"ESCAPE");
2952
    return TRUE;
2953 2954 2955 2956 2957 2958
  }
  
  if (escape_item->const_item())
  {
    /* If we are on execution stage */
    String *escape_str= escape_item->val_str(&tmp_value1);
2959 2960
    if (escape_str)
    {
2961 2962 2963 2964 2965 2966 2967 2968 2969
      if (escape_used_in_parsing && (
             (((thd->variables.sql_mode & MODE_NO_BACKSLASH_ESCAPES) &&
                escape_str->numchars() != 1) ||
               escape_str->numchars() > 1)))
      {
        my_error(ER_WRONG_ARGUMENTS,MYF(0),"ESCAPE");
        return TRUE;
      }

bar@mysql.com's avatar
bar@mysql.com committed
2970
      if (use_mb(cmp.cmp_collation.collation))
2971
      {
2972
        CHARSET_INFO *cs= escape_str->charset();
2973 2974 2975 2976 2977 2978 2979 2980 2981
        my_wc_t wc;
        int rc= cs->cset->mb_wc(cs, &wc,
                                (const uchar*) escape_str->ptr(),
                                (const uchar*) escape_str->ptr() +
                                               escape_str->length());
        escape= (int) (rc > 0 ? wc : '\\');
      }
      else
      {
2982 2983 2984 2985 2986
        /*
          In the case of 8bit character set, we pass native
          code instead of Unicode code as "escape" argument.
          Convert to "cs" if charset of escape differs.
        */
bar@mysql.com's avatar
bar@mysql.com committed
2987
        CHARSET_INFO *cs= cmp.cmp_collation.collation;
2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000
        uint32 unused;
        if (escape_str->needs_conversion(escape_str->length(),
                                         escape_str->charset(), cs, &unused))
        {
          char ch;
          uint errors;
          uint32 cnvlen= copy_and_convert(&ch, 1, cs, escape_str->ptr(),
                                          escape_str->length(),
                                          escape_str->charset(), &errors);
          escape= cnvlen ? ch : '\\';
        }
        else
          escape= *(escape_str->ptr());
3001 3002 3003 3004
      }
    }
    else
      escape= '\\';
3005

3006
    /*
3007 3008
      We could also do boyer-more for non-const items, but as we would have to
      recompute the tables for each row it's not worth it.
3009
    */
3010 3011
    if (args[1]->const_item() && !use_strnxfrm(collation.collation) &&
       !(specialflag & SPECIAL_NO_NEW_FUNC))
3012
    {
3013 3014
      String* res2 = args[1]->val_str(&tmp_value2);
      if (!res2)
3015
        return FALSE;				// Null argument
3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035
      
      const size_t len   = res2->length();
      const char*  first = res2->ptr();
      const char*  last  = first + len - 1;
      /*
        len must be > 2 ('%pattern%')
        heuristic: only do TurboBM for pattern_len > 2
      */
      
      if (len > MIN_TURBOBM_PATTERN_LEN + 2 &&
          *first == wild_many &&
          *last  == wild_many)
      {
        const char* tmp = first + 1;
        for (; *tmp != wild_many && *tmp != wild_one && *tmp != escape; tmp++) ;
        canDoTurboBM = (tmp == last) && !use_mb(args[0]->collation.collation);
      }
      if (canDoTurboBM)
      {
        pattern     = first + 1;
3036
        pattern_len = (int) len - 2;
3037
        DBUG_PRINT("info", ("Initializing pattern: '%s'", first));
3038 3039 3040
        int *suff = (int*) thd->alloc((int) (sizeof(int)*
                                      ((pattern_len + 1)*2+
                                      alphabet_size)));
3041 3042 3043 3044 3045 3046
        bmGs      = suff + pattern_len + 1;
        bmBc      = bmGs + pattern_len + 1;
        turboBM_compute_good_suffix_shifts(suff);
        turboBM_compute_bad_character_shifts();
        DBUG_PRINT("info",("done"));
      }
3047 3048
    }
  }
3049
  return FALSE;
3050 3051
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3052 3053 3054
#ifdef USE_REGEX

bool
3055
Item_func_regex::fix_fields(THD *thd, Item **ref)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3056
{
3057
  DBUG_ASSERT(fixed == 0);
3058
  if ((!args[0]->fixed &&
3059
       args[0]->fix_fields(thd, args)) || args[0]->check_cols(1) ||
3060
      (!args[1]->fixed &&
3061
       args[1]->fix_fields(thd, args + 1)) || args[1]->check_cols(1))
3062
    return TRUE;				/* purecov: inspected */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3063
  with_sum_func=args[0]->with_sum_func || args[1]->with_sum_func;
3064 3065
  max_length= 1;
  decimals= 0;
3066

bar@mysql.com's avatar
bar@mysql.com committed
3067
  if (agg_arg_charsets(cmp_collation, args, 2, MY_COLL_CMP_CONV))
3068
    return TRUE;
3069

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3070
  used_tables_cache=args[0]->used_tables() | args[1]->used_tables();
3071 3072
  not_null_tables_cache= (args[0]->not_null_tables() |
			  args[1]->not_null_tables());
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3073 3074 3075 3076
  const_item_cache=args[0]->const_item() && args[1]->const_item();
  if (!regex_compiled && args[1]->const_item())
  {
    char buff[MAX_FIELD_WIDTH];
3077
    String tmp(buff,sizeof(buff),&my_charset_bin);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3078 3079 3080 3081
    String *res=args[1]->val_str(&tmp);
    if (args[1]->null_value)
    {						// Will always return NULL
      maybe_null=1;
3082
      return FALSE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3083 3084
    }
    int error;
kent@mysql.com's avatar
kent@mysql.com committed
3085 3086 3087 3088 3089 3090
    if ((error= my_regcomp(&preg,res->c_ptr(),
                           ((cmp_collation.collation->state &
                             (MY_CS_BINSORT | MY_CS_CSSORT)) ?
                            REG_EXTENDED | REG_NOSUB :
                            REG_EXTENDED | REG_NOSUB | REG_ICASE),
                           cmp_collation.collation)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3091
    {
kent@mysql.com's avatar
kent@mysql.com committed
3092
      (void) my_regerror(error,&preg,buff,sizeof(buff));
3093
      my_error(ER_REGEXP_ERROR, MYF(0), buff);
3094
      return TRUE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3095 3096 3097 3098 3099 3100
    }
    regex_compiled=regex_is_const=1;
    maybe_null=args[0]->maybe_null;
  }
  else
    maybe_null=1;
3101
  fixed= 1;
3102
  return FALSE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3103 3104
}

3105

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3106 3107
longlong Item_func_regex::val_int()
{
3108
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3109
  char buff[MAX_FIELD_WIDTH];
3110
  String *res, tmp(buff,sizeof(buff),&my_charset_bin);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3111 3112 3113 3114 3115 3116 3117 3118 3119 3120

  res=args[0]->val_str(&tmp);
  if (args[0]->null_value)
  {
    null_value=1;
    return 0;
  }
  if (!regex_is_const)
  {
    char buff2[MAX_FIELD_WIDTH];
3121
    String *res2, tmp2(buff2,sizeof(buff2),&my_charset_bin);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3122 3123 3124 3125 3126 3127 3128

    res2= args[1]->val_str(&tmp2);
    if (args[1]->null_value)
    {
      null_value=1;
      return 0;
    }
monty@mysql.com's avatar
monty@mysql.com committed
3129
    if (!regex_compiled || stringcmp(res2,&prev_regexp))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3130 3131 3132 3133
    {
      prev_regexp.copy(*res2);
      if (regex_compiled)
      {
kent@mysql.com's avatar
kent@mysql.com committed
3134
	my_regfree(&preg);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3135 3136
	regex_compiled=0;
      }
kent@mysql.com's avatar
Merge  
kent@mysql.com committed
3137
      if (my_regcomp(&preg,res2->c_ptr_safe(),
kent@mysql.com's avatar
kent@mysql.com committed
3138 3139 3140 3141 3142
                     ((cmp_collation.collation->state &
                       (MY_CS_BINSORT | MY_CS_CSSORT)) ?
                      REG_EXTENDED | REG_NOSUB :
                      REG_EXTENDED | REG_NOSUB | REG_ICASE),
                     cmp_collation.collation))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3143 3144 3145 3146 3147 3148 3149 3150
      {
	null_value=1;
	return 0;
      }
      regex_compiled=1;
    }
  }
  null_value=0;
kent@mysql.com's avatar
kent@mysql.com committed
3151
  return my_regexec(&preg,res->c_ptr(),0,(my_regmatch_t*) 0,0) ? 0 : 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3152 3153 3154
}


3155
void Item_func_regex::cleanup()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3156
{
3157 3158
  DBUG_ENTER("Item_func_regex::cleanup");
  Item_bool_func::cleanup();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3159 3160
  if (regex_compiled)
  {
kent@mysql.com's avatar
kent@mysql.com committed
3161
    my_regfree(&preg);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3162 3163
    regex_compiled=0;
  }
3164
  DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3165 3166
}

3167

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3168
#endif /* USE_REGEX */
3169 3170 3171


#ifdef LIKE_CMP_TOUPPER
3172
#define likeconv(cs,A) (uchar) (cs)->toupper(A)
3173
#else
3174
#define likeconv(cs,A) (uchar) (cs)->sort_order[(uchar) (A)]
3175 3176 3177 3178 3179 3180 3181 3182
#endif


/**********************************************************************
  turboBM_compute_suffixes()
  Precomputation dependent only on pattern_len.
**********************************************************************/

3183
void Item_func_like::turboBM_compute_suffixes(int *suff)
3184 3185 3186 3187
{
  const int   plm1 = pattern_len - 1;
  int            f = 0;
  int            g = plm1;
3188
  int *const splm1 = suff + plm1;
3189
  CHARSET_INFO	*cs= cmp.cmp_collation.collation;
3190 3191 3192

  *splm1 = pattern_len;

bar@mysql.com's avatar
bar@mysql.com committed
3193
  if (!cs->sort_order)
3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224
  {
    int i;
    for (i = pattern_len - 2; i >= 0; i--)
    {
      int tmp = *(splm1 + i - f);
      if (g < i && tmp < i - g)
	suff[i] = tmp;
      else
      {
	if (i < g)
	  g = i; // g = min(i, g)
	f = i;
	while (g >= 0 && pattern[g] == pattern[g + plm1 - f])
	  g--;
	suff[i] = f - g;
      }
    }
  }
  else
  {
    int i;
    for (i = pattern_len - 2; 0 <= i; --i)
    {
      int tmp = *(splm1 + i - f);
      if (g < i && tmp < i - g)
	suff[i] = tmp;
      else
      {
	if (i < g)
	  g = i; // g = min(i, g)
	f = i;
3225
	while (g >= 0 &&
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3226
	       likeconv(cs, pattern[g]) == likeconv(cs, pattern[g + plm1 - f]))
3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239
	  g--;
	suff[i] = f - g;
      }
    }
  }
}


/**********************************************************************
   turboBM_compute_good_suffix_shifts()
   Precomputation dependent only on pattern_len.
**********************************************************************/

3240
void Item_func_like::turboBM_compute_good_suffix_shifts(int *suff)
3241 3242 3243
{
  turboBM_compute_suffixes(suff);

3244 3245
  int *end = bmGs + pattern_len;
  int *k;
3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258
  for (k = bmGs; k < end; k++)
    *k = pattern_len;

  int tmp;
  int i;
  int j          = 0;
  const int plm1 = pattern_len - 1;
  for (i = plm1; i > -1; i--)
  {
    if (suff[i] == i + 1)
    {
      for (tmp = plm1 - i; j < tmp; j++)
      {
3259
	int *tmp2 = bmGs + j;
3260 3261 3262 3263 3264 3265
	if (*tmp2 == pattern_len)
	  *tmp2 = tmp;
      }
    }
  }

3266
  int *tmp2;
3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286
  for (tmp = plm1 - i; j < tmp; j++)
  {
    tmp2 = bmGs + j;
    if (*tmp2 == pattern_len)
      *tmp2 = tmp;
  }

  tmp2 = bmGs + plm1;
  for (i = 0; i <= pattern_len - 2; i++)
    *(tmp2 - suff[i]) = plm1 - i;
}


/**********************************************************************
   turboBM_compute_bad_character_shifts()
   Precomputation dependent on pattern_len.
**********************************************************************/

void Item_func_like::turboBM_compute_bad_character_shifts()
{
3287 3288 3289 3290
  int *i;
  int *end = bmBc + alphabet_size;
  int j;
  const int plm1 = pattern_len - 1;
3291
  CHARSET_INFO	*cs= cmp.cmp_collation.collation;
3292

3293 3294 3295
  for (i = bmBc; i < end; i++)
    *i = pattern_len;

bar@mysql.com's avatar
bar@mysql.com committed
3296
  if (!cs->sort_order)
3297
  {
3298
    for (j = 0; j < plm1; j++)
3299
      bmBc[(uint) (uchar) pattern[j]] = plm1 - j;
3300
  }
3301
  else
3302
  {
3303
    for (j = 0; j < plm1; j++)
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3304
      bmBc[(uint) likeconv(cs,pattern[j])] = plm1 - j;
3305
  }
3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320
}


/**********************************************************************
  turboBM_matches()
  Search for pattern in text, returns true/false for match/no match
**********************************************************************/

bool Item_func_like::turboBM_matches(const char* text, int text_len) const
{
  register int bcShift;
  register int turboShift;
  int shift = pattern_len;
  int j     = 0;
  int u     = 0;
3321
  CHARSET_INFO	*cs= cmp.cmp_collation.collation;
3322

3323 3324
  const int plm1=  pattern_len - 1;
  const int tlmpl= text_len - pattern_len;
3325 3326

  /* Searching */
bar@mysql.com's avatar
bar@mysql.com committed
3327
  if (!cs->sort_order)
3328 3329 3330
  {
    while (j <= tlmpl)
    {
3331
      register int i= plm1;
3332 3333 3334 3335
      while (i >= 0 && pattern[i] == text[i + j])
      {
	i--;
	if (i == plm1 - shift)
3336
	  i-= u;
3337 3338
      }
      if (i < 0)
3339
	return 1;
3340 3341 3342

      register const int v = plm1 - i;
      turboShift = u - v;
3343
      bcShift    = bmBc[(uint) (uchar) text[i + j]] - plm1 + i;
3344 3345 3346 3347 3348 3349 3350 3351 3352 3353
      shift      = max(turboShift, bcShift);
      shift      = max(shift, bmGs[i]);
      if (shift == bmGs[i])
	u = min(pattern_len - shift, v);
      else
      {
	if (turboShift < bcShift)
	  shift = max(shift, u + 1);
	u = 0;
      }
3354
      j+= shift;
3355
    }
3356
    return 0;
3357 3358 3359 3360 3361 3362
  }
  else
  {
    while (j <= tlmpl)
    {
      register int i = plm1;
3363
      while (i >= 0 && likeconv(cs,pattern[i]) == likeconv(cs,text[i + j]))
3364 3365 3366
      {
	i--;
	if (i == plm1 - shift)
3367
	  i-= u;
3368 3369
      }
      if (i < 0)
3370
	return 1;
3371 3372 3373

      register const int v = plm1 - i;
      turboShift = u - v;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
3374
      bcShift    = bmBc[(uint) likeconv(cs, text[i + j])] - plm1 + i;
3375 3376 3377 3378 3379 3380 3381 3382 3383 3384
      shift      = max(turboShift, bcShift);
      shift      = max(shift, bmGs[i]);
      if (shift == bmGs[i])
	u = min(pattern_len - shift, v);
      else
      {
	if (turboShift < bcShift)
	  shift = max(shift, u + 1);
	u = 0;
      }
3385
      j+= shift;
3386
    }
3387
    return 0;
3388 3389
  }
}
3390

3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411

/*
  Make a logical XOR of the arguments.

  SYNOPSIS
    val_int()

  DESCRIPTION
  If either operator is NULL, return NULL.

  NOTE
    As we don't do any index optimization on XOR this is not going to be
    very fast to use.

  TODO (low priority)
    Change this to be optimized as:
      A XOR B   ->  (A) == 1 AND (B) <> 1) OR (A <> 1 AND (B) == 1)
    To be able to do this, we would however first have to extend the MySQL
    range optimizer to handle OR better.
*/

3412 3413
longlong Item_cond_xor::val_int()
{
3414
  DBUG_ASSERT(fixed == 1);
3415 3416 3417
  List_iterator<Item> li(list);
  Item *item;
  int result=0;	
3418
  null_value=0;
3419 3420
  while ((item=li++))
  {
3421 3422 3423 3424 3425 3426
    result^= (item->val_int() != 0);
    if (item->null_value)
    {
      null_value=1;
      return 0;
    }
3427
  }
3428
  return (longlong) result;
3429
}
3430 3431 3432 3433

/*
  Apply NOT transformation to the item and return a new one.

3434
  SYNOPSIS
3435
    neg_transformer()
3436
    thd		thread handler
3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456

  DESCRIPTION
    Transform the item using next rules:
       a AND b AND ...    -> NOT(a) OR NOT(b) OR ...
       a OR b OR ...      -> NOT(a) AND NOT(b) AND ...
       NOT(a)             -> a
       a = b              -> a != b
       a != b             -> a = b
       a < b              -> a >= b
       a >= b             -> a < b
       a > b              -> a <= b
       a <= b             -> a > b
       IS NULL(a)         -> IS NOT NULL(a)
       IS NOT NULL(a)     -> IS NULL(a)

  RETURN
    New item or
    NULL if we cannot apply NOT transformation (see Item::neg_transformer()).
*/

3457
Item *Item_func_not::neg_transformer(THD *thd)	/* NOT(x)  ->  x */
3458
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3459
  return args[0];
3460 3461
}

3462 3463

Item *Item_bool_rowready_func2::neg_transformer(THD *thd)
3464
{
3465 3466
  Item *item= negated_item();
  return item;
3467 3468
}

3469 3470 3471

/* a IS NULL  ->  a IS NOT NULL */
Item *Item_func_isnull::neg_transformer(THD *thd)
3472
{
3473 3474
  Item *item= new Item_func_isnotnull(args[0]);
  return item;
3475 3476
}

3477 3478 3479

/* a IS NOT NULL  ->  a IS NULL */
Item *Item_func_isnotnull::neg_transformer(THD *thd)
3480
{
3481 3482
  Item *item= new Item_func_isnull(args[0]);
  return item;
3483 3484
}

3485 3486 3487

Item *Item_cond_and::neg_transformer(THD *thd)	/* NOT(a AND b AND ...)  -> */
					/* NOT a OR NOT b OR ... */
3488
{
3489 3490 3491
  neg_arguments(thd);
  Item *item= new Item_cond_or(list);
  return item;
3492 3493
}

3494 3495 3496

Item *Item_cond_or::neg_transformer(THD *thd)	/* NOT(a OR b OR ...)  -> */
					/* NOT a AND NOT b AND ... */
3497
{
3498 3499 3500
  neg_arguments(thd);
  Item *item= new Item_cond_and(list);
  return item;
3501 3502
}

3503 3504

Item *Item_func_eq::negated_item()		/* a = b  ->  a != b */
3505
{
3506
  return new Item_func_ne(args[0], args[1]);
3507 3508
}

3509 3510

Item *Item_func_ne::negated_item()		/* a != b  ->  a = b */
3511
{
3512
  return new Item_func_eq(args[0], args[1]);
3513 3514
}

3515 3516

Item *Item_func_lt::negated_item()		/* a < b  ->  a >= b */
3517
{
3518
  return new Item_func_ge(args[0], args[1]);
3519 3520
}

3521 3522

Item *Item_func_ge::negated_item()		/* a >= b  ->  a < b */
3523
{
3524
  return new Item_func_lt(args[0], args[1]);
3525 3526
}

3527 3528

Item *Item_func_gt::negated_item()		/* a > b  ->  a <= b */
3529
{
3530
  return new Item_func_le(args[0], args[1]);
3531 3532
}

3533 3534

Item *Item_func_le::negated_item()		/* a <= b  ->  a > b */
3535
{
3536
  return new Item_func_gt(args[0], args[1]);
3537 3538
}

3539 3540
// just fake method, should never be called
Item *Item_bool_rowready_func2::negated_item()
3541
{
3542 3543
  DBUG_ASSERT(0);
  return 0;
3544
}
3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561

Item_equal::Item_equal(Item_field *f1, Item_field *f2)
  : Item_bool_func(), const_item(0), eval_item(0), cond_false(0)
{
  const_item_cache= 0;
  fields.push_back(f1);
  fields.push_back(f2);
}

Item_equal::Item_equal(Item *c, Item_field *f)
  : Item_bool_func(), eval_item(0), cond_false(0)
{
  const_item_cache= 0;
  fields.push_back(f);
  const_item= c;
}

3562

3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587
Item_equal::Item_equal(Item_equal *item_equal)
  : Item_bool_func(), eval_item(0), cond_false(0)
{
  const_item_cache= 0;
  List_iterator_fast<Item_field> li(item_equal->fields);
  Item_field *item;
  while ((item= li++))
  {
    fields.push_back(item);
  }
  const_item= item_equal->const_item;
  cond_false= item_equal->cond_false;
}

void Item_equal::add(Item *c)
{
  if (cond_false)
    return;
  if (!const_item)
  {
    const_item= c;
    return;
  }
  Item_func_eq *func= new Item_func_eq(c, const_item);
  func->set_cmp_func();
3588
  func->quick_fix_field();
3589 3590 3591 3592 3593 3594 3595 3596
  cond_false =  !(func->val_int());
}

void Item_equal::add(Item_field *f)
{
  fields.push_back(f);
}

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3597 3598
uint Item_equal::members()
{
3599
  return fields.elements;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3600 3601 3602 3603 3604 3605 3606 3607
}


/*
  Check whether a field is referred in the multiple equality 

  SYNOPSIS
    contains()
3608
    field   field whose occurrence is to be checked
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3609 3610
  
  DESCRIPTION
3611
    The function checks whether field is occurred in the Item_equal object 
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3612 3613 3614 3615 3616 3617
    
  RETURN VALUES
    1       if nultiple equality contains a reference to field
    0       otherwise    
*/

3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629
bool Item_equal::contains(Field *field)
{
  List_iterator_fast<Item_field> it(fields);
  Item_field *item;
  while ((item= it++))
  {
    if (field->eq(item->field))
        return 1;
  }
  return 0;
}

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3630 3631 3632 3633 3634 3635 3636 3637 3638

/*
  Join members of another Item_equal object  

  SYNOPSIS
    merge()
    item    multiple equality whose members are to be joined
  
  DESCRIPTION
3639
    The function actually merges two multiple equalities.
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3640 3641 3642 3643 3644 3645 3646 3647 3648
    After this operation the Item_equal object additionally contains
    the field items of another item of the type Item_equal.
    If the optional constant items are not equal the cond_false flag is
    set to 1.  
       
  RETURN VALUES
    none    
*/

3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664
void Item_equal::merge(Item_equal *item)
{
  fields.concat(&item->fields);
  Item *c= item->const_item;
  if (c)
  {
    /* 
      The flag cond_false will be set to 1 after this, if 
      the multiple equality already contains a constant and its 
      value is  not equal to the value of c.
    */
    add(const_item);
  }
  cond_false|= item->cond_false;
} 

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690

/*
  Order field items in multiple equality according to a sorting criteria 

  SYNOPSIS
    sort()
    cmp          function to compare field item 
    arg          context extra parameter for the cmp function
  
  DESCRIPTION
    The function perform ordering of the field items in the Item_equal
    object according to the criteria determined by the cmp callback parameter.
    If cmp(item_field1,item_field2,arg)<0 than item_field1 must be
    placed after item_fiel2.

  IMPLEMENTATION
    The function sorts field items by the exchange sort algorithm.
    The list of field items is looked through and whenever two neighboring
    members follow in a wrong order they are swapped. This is performed
    again and again until we get all members in a right order.
         
  RETURN VALUES
    None    
*/

void Item_equal::sort(Item_field_cmpfunc cmp, void *arg)
3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702
{
  bool swap;
  List_iterator<Item_field> it(fields);
  do
  {
    Item_field *item1= it++;
    Item_field **ref1= it.ref();
    Item_field *item2;

    swap= FALSE;
    while ((item2= it++))
    {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3703 3704
      Item_field **ref2= it.ref();
      if (cmp(item1, item2, arg) < 0)
3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720
      {
        Item_field *item= *ref1;
        *ref1= *ref2;
        *ref2= item;
        swap= TRUE;
      }
      else
      {
        item1= item2;
        ref1= ref2;
      }
    }
    it.rewind();
  } while (swap);
}

3721
bool Item_equal::fix_fields(THD *thd, Item **ref)
3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745
{
  List_iterator_fast<Item_field> li(fields);
  Item *item;
  not_null_tables_cache= used_tables_cache= 0;
  const_item_cache= 0;
  while ((item=li++))
  {
    table_map tmp_table_map;
    used_tables_cache|= item->used_tables();
    tmp_table_map= item->not_null_tables();
    not_null_tables_cache|= tmp_table_map;
    if (item->maybe_null)
      maybe_null=1;
  }
  fix_length_and_dec();
  fixed= 1;
  return 0;
}

void Item_equal::update_used_tables()
{
  List_iterator_fast<Item_field> li(fields);
  Item *item;
  not_null_tables_cache= used_tables_cache= 0;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3746 3747
  if ((const_item_cache= cond_false))
    return;
3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764
  while ((item=li++))
  {
    item->update_used_tables();
    used_tables_cache|= item->used_tables();
    const_item_cache&= item->const_item();
  }
}

longlong Item_equal::val_int()
{
  if (cond_false)
    return 0;
  List_iterator_fast<Item_field> it(fields);
  Item *item= const_item ? const_item : it++;
  if ((null_value= item->null_value))
    return 0;
  eval_item->store_value(item);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3765
  while ((item= it++))
3766 3767 3768 3769 3770 3771 3772 3773 3774 3775
  {
    if ((null_value= item->null_value) || eval_item->cmp(item))
      return 0;
  }
  return 1;
}

void Item_equal::fix_length_and_dec()
{
  Item *item= const_item ? const_item : get_first();
3776 3777
  eval_item= cmp_item::get_comparator(item->result_type(),
                                      item->collation.collation);
3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791
  if (item->result_type() == STRING_RESULT)
    eval_item->cmp_charset= cmp_collation.collation;
}

bool Item_equal::walk(Item_processor processor, byte *arg)
{
  List_iterator_fast<Item_field> it(fields);
  Item *item;
  while ((item= it++))
    if (item->walk(processor, arg))
      return 1;
  return Item_func::walk(processor, arg);
}

igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3792
Item *Item_equal::transform(Item_transformer transformer, byte *arg)
3793 3794 3795 3796 3797
{
  List_iterator<Item_field> it(fields);
  Item *item;
  while ((item= it++))
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3798
    Item *new_item= item->transform(transformer, arg);
3799 3800 3801 3802 3803
    if (!new_item)
      return 0;
    if (new_item != item)
      it.replace((Item_field *) new_item);
  }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3804
  return Item_func::transform(transformer, arg);
3805 3806 3807 3808 3809 3810 3811 3812
}

void Item_equal::print(String *str)
{
  str->append(func_name());
  str->append('(');
  List_iterator_fast<Item_field> it(fields);
  Item *item;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3813 3814 3815 3816 3817
  if (const_item)
    const_item->print(str);
  else
  {
    item= it++;
3818
    item->print(str);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3819
  }
3820 3821 3822 3823 3824 3825 3826 3827 3828
  while ((item= it++))
  {
    str->append(',');
    str->append(' ');
    item->print(str);
  }
  str->append(')');
}