item.cc 192 KB
Newer Older
1
/* Copyright (C) 2000-2006 MySQL 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
   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
5
   the Free Software Foundation; version 2 of the License.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6

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

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


17
#ifdef USE_PRAGMA_IMPLEMENTATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
18 19 20 21 22
#pragma implementation				// gcc: Class implementation
#endif
#include "mysql_priv.h"
#include <m_ctype.h>
#include "my_dir.h"
23
#include "sp_rcontext.h"
24 25
#include "sp_head.h"
#include "sql_trigger.h"
26
#include "sql_select.h"
bk@work.mysql.com's avatar
bk@work.mysql.com committed
27

28 29
const String my_null_string("NULL", 4, default_charset_info);

30 31 32 33 34 35 36 37 38 39
/****************************************************************************/

/* Hybrid_type_traits {_real} */

void Hybrid_type_traits::fix_length_and_dec(Item *item, Item *arg) const
{
  item->decimals= NOT_FIXED_DEC;
  item->max_length= item->float_length(arg->decimals);
}

40
static const Hybrid_type_traits real_traits_instance;
41 42 43

const Hybrid_type_traits *Hybrid_type_traits::instance()
{
44
  return &real_traits_instance;
45 46 47 48 49 50 51 52 53 54 55 56 57 58
}


my_decimal *
Hybrid_type_traits::val_decimal(Hybrid_type *val, my_decimal *to) const
{
  double2my_decimal(E_DEC_FATAL_ERROR, val->real, val->dec_buf);
  return val->dec_buf;
}


String *
Hybrid_type_traits::val_str(Hybrid_type *val, String *to, uint8 decimals) const
{
59
  to->set_real(val->real, decimals, &my_charset_bin);
60 61 62 63
  return to;
}

/* Hybrid_type_traits_decimal */
64
static const Hybrid_type_traits_decimal decimal_traits_instance;
65 66 67

const Hybrid_type_traits_decimal *Hybrid_type_traits_decimal::instance()
{
68
  return &decimal_traits_instance;
69 70 71 72 73 74 75 76
}


void
Hybrid_type_traits_decimal::fix_length_and_dec(Item *item, Item *arg) const
{
  item->decimals= arg->decimals;
  item->max_length= min(arg->max_length + DECIMAL_LONGLONG_DIGITS,
77
                        DECIMAL_MAX_STR_LENGTH);
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
}


void Hybrid_type_traits_decimal::set_zero(Hybrid_type *val) const
{
  my_decimal_set_zero(&val->dec_buf[0]);
  val->used_dec_buf_no= 0;
}


void Hybrid_type_traits_decimal::add(Hybrid_type *val, Field *f) const
{
  my_decimal_add(E_DEC_FATAL_ERROR,
                 &val->dec_buf[val->used_dec_buf_no ^ 1],
                 &val->dec_buf[val->used_dec_buf_no],
                 f->val_decimal(&val->dec_buf[2]));
  val->used_dec_buf_no^= 1;
}


98 99 100 101
/**
  @todo
  what is '4' for scale?
*/
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
void Hybrid_type_traits_decimal::div(Hybrid_type *val, ulonglong u) const
{
  int2my_decimal(E_DEC_FATAL_ERROR, u, TRUE, &val->dec_buf[2]);
  /* XXX: what is '4' for scale? */
  my_decimal_div(E_DEC_FATAL_ERROR,
                 &val->dec_buf[val->used_dec_buf_no ^ 1],
                 &val->dec_buf[val->used_dec_buf_no],
                 &val->dec_buf[2], 4);
  val->used_dec_buf_no^= 1;
}


longlong
Hybrid_type_traits_decimal::val_int(Hybrid_type *val, bool unsigned_flag) const
{
  longlong result;
  my_decimal2int(E_DEC_FATAL_ERROR, &val->dec_buf[val->used_dec_buf_no],
                 unsigned_flag, &result);
  return result;
}


double
Hybrid_type_traits_decimal::val_real(Hybrid_type *val) const
{
  my_decimal2double(E_DEC_FATAL_ERROR, &val->dec_buf[val->used_dec_buf_no],
                    &val->real);
  return val->real;
}


String *
Hybrid_type_traits_decimal::val_str(Hybrid_type *val, String *to,
                                    uint8 decimals) const
{
  my_decimal_round(E_DEC_FATAL_ERROR, &val->dec_buf[val->used_dec_buf_no],
                   decimals, FALSE, &val->dec_buf[2]);
  my_decimal2string(E_DEC_FATAL_ERROR, &val->dec_buf[2], 0, 0, 0, to);
  return to;
}

/* Hybrid_type_traits_integer */
144
static const Hybrid_type_traits_integer integer_traits_instance;
145 146 147

const Hybrid_type_traits_integer *Hybrid_type_traits_integer::instance()
{
148
  return &integer_traits_instance;
149 150 151 152 153 154
}

void
Hybrid_type_traits_integer::fix_length_and_dec(Item *item, Item *arg) const
{
  item->decimals= 0;
155
  item->max_length= MY_INT64_NUM_DECIMAL_DIGITS;
156 157 158
  item->unsigned_flag= 0;
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
159 160 161 162
/*****************************************************************************
** Item functions
*****************************************************************************/

163 164 165
/**
  Init all special items.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
166 167 168 169

void item_init(void)
{
  item_user_lock_init();
170
  uuid_short_init();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
171 172
}

173

174 175 176
/**
  @todo
    Make this functions class dependent
177
*/
178

179 180
bool Item::val_bool()
{
181
  switch(result_type()) {
182
  case INT_RESULT:
183
    return val_int() != 0;
184 185 186 187 188 189 190 191 192 193 194 195 196 197
  case DECIMAL_RESULT:
  {
    my_decimal decimal_value;
    my_decimal *val= val_decimal(&decimal_value);
    if (val)
      return !my_decimal_is_zero(val);
    return 0;
  }
  case REAL_RESULT:
  case STRING_RESULT:
    return val_real() != 0.0;
  case ROW_RESULT:
  default:
    DBUG_ASSERT(0);
198
    return 0;                                   // Wrong (but safe)
199 200 201 202
  }
}


203 204 205 206 207
String *Item::val_string_from_real(String *str)
{
  double nr= val_real();
  if (null_value)
    return 0;					/* purecov: inspected */
208
  str->set_real(nr,decimals, &my_charset_bin);
209 210 211 212 213 214 215 216 217
  return str;
}


String *Item::val_string_from_int(String *str)
{
  longlong nr= val_int();
  if (null_value)
    return 0;
218
  str->set_int(nr, unsigned_flag, &my_charset_bin);
219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
  return str;
}


String *Item::val_string_from_decimal(String *str)
{
  my_decimal dec_buf, *dec= val_decimal(&dec_buf);
  if (null_value)
    return 0;
  my_decimal_round(E_DEC_FATAL_ERROR, dec, decimals, FALSE, &dec_buf);
  my_decimal2string(E_DEC_FATAL_ERROR, &dec_buf, 0, 0, 0, str);
  return str;
}


my_decimal *Item::val_decimal_from_real(my_decimal *decimal_value)
{
  double nr= val_real();
  if (null_value)
    return 0;
  double2my_decimal(E_DEC_FATAL_ERROR, nr, decimal_value);
  return (decimal_value);
}


my_decimal *Item::val_decimal_from_int(my_decimal *decimal_value)
{
  longlong nr= val_int();
  if (null_value)
    return 0;
  int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value);
  return decimal_value;
}


my_decimal *Item::val_decimal_from_string(my_decimal *decimal_value)
{
  String *res;
  char *end_ptr;
  if (!(res= val_str(&str_value)))
    return 0;                                   // NULL or EOM

  end_ptr= (char*) res->ptr()+ res->length();
262 263 264 265 266 267 268 269 270
  if (str2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_BAD_NUM,
                     res->ptr(), res->length(), res->charset(),
                     decimal_value) & E_DEC_BAD_NUM)
  {
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_TRUNCATED_WRONG_VALUE,
                        ER(ER_TRUNCATED_WRONG_VALUE), "DECIMAL",
                        str_value.c_ptr());
  }
271 272 273 274
  return decimal_value;
}


275 276 277
my_decimal *Item::val_decimal_from_date(my_decimal *decimal_value)
{
  DBUG_ASSERT(fixed == 1);
278
  MYSQL_TIME ltime;
279 280 281
  if (get_date(&ltime, TIME_FUZZY_DATE))
  {
    my_decimal_set_zero(decimal_value);
282
    null_value= 1;                               // set NULL, stop processing
283 284 285 286 287 288 289 290 291
    return 0;
  }
  return date2my_decimal(&ltime, decimal_value);
}


my_decimal *Item::val_decimal_from_time(my_decimal *decimal_value)
{
  DBUG_ASSERT(fixed == 1);
292
  MYSQL_TIME ltime;
293 294 295 296 297 298 299 300 301
  if (get_time(&ltime))
  {
    my_decimal_set_zero(decimal_value);
    return 0;
  }
  return date2my_decimal(&ltime, decimal_value);
}


302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
double Item::val_real_from_decimal()
{
  /* Note that fix_fields may not be called for Item_avg_field items */
  double result;
  my_decimal value_buff, *dec_val= val_decimal(&value_buff);
  if (null_value)
    return 0.0;
  my_decimal2double(E_DEC_FATAL_ERROR, dec_val, &result);
  return result;
}


longlong Item::val_int_from_decimal()
{
  /* Note that fix_fields may not be called for Item_avg_field items */
  longlong result;
  my_decimal value, *dec_val= val_decimal(&value);
  if (null_value)
    return 0;
  my_decimal2int(E_DEC_FATAL_ERROR, dec_val, unsigned_flag, &result);
  return result;
}

325 326
int Item::save_time_in_field(Field *field)
{
327
  MYSQL_TIME ltime;
328 329 330 331 332 333 334 335 336
  if (get_time(&ltime))
    return set_field_to_null(field);
  field->set_notnull();
  return field->store_time(&ltime, MYSQL_TIMESTAMP_TIME);
}


int Item::save_date_in_field(Field *field)
{
337
  MYSQL_TIME ltime;
338 339 340 341 342 343
  if (get_date(&ltime, TIME_FUZZY_DATE))
    return set_field_to_null(field);
  field->set_notnull();
  return field->store_time(&ltime, MYSQL_TIMESTAMP_DATETIME);
}

344

345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
/*
  Store the string value in field directly

  SYNOPSIS
    Item::save_str_value_in_field()
    field   a pointer to field where to store
    result  the pointer to the string value to be stored

  DESCRIPTION
    The method is used by Item_*::save_in_field implementations
    when we don't need to calculate the value to store
    See Item_string::save_in_field() implementation for example

  IMPLEMENTATION
    Check if the Item is null and stores the NULL or the
    result value in the field accordingly.

  RETURN
    Nonzero value if error
*/

int Item::save_str_value_in_field(Field *field, String *result)
{
  if (null_value)
    return set_field_to_null(field);
  field->set_notnull();
  return field->store(result->ptr(), result->length(),
		      collation.collation);
}


376
Item::Item():
377
  rsize(0), name(0), orig_name(0), name_length(0), fixed(0),
378
  is_autogenerated_name(TRUE),
bar@mysql.com's avatar
bar@mysql.com committed
379
  collation(&my_charset_bin, DERIVATION_COERCIBLE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
380
{
381
  marker= 0;
382
  maybe_null=null_value=with_sum_func=unsigned_flag=0;
383
  decimals= 0; max_length= 0;
384
  with_subselect= 0;
385
  cmp_context= (Item_result)-1;
386 387 388

  /* Put item in free list so that we can free all items at end */
  THD *thd= current_thd;
389 390
  next= thd->free_list;
  thd->free_list= this;
391
  /*
392
    Item constructor can be called during execution other then SQL_COM
393
    command => we should check thd->lex->current_select on zero (thd->lex
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
394
    can be uninitialised)
395
  */
pem@mysql.telia.com's avatar
pem@mysql.telia.com committed
396
  if (thd->lex->current_select)
397
  {
398
    enum_parsing_place place= 
pem@mysql.com's avatar
pem@mysql.com committed
399
      thd->lex->current_select->parsing_place;
400 401
    if (place == SELECT_LIST ||
	place == IN_HAVING)
pem@mysql.com's avatar
pem@mysql.com committed
402
      thd->lex->current_select->select_n_having_items++;
403
  }
404 405
}

406 407 408 409
/**
  Constructor used by Item_field, Item_ref & aggregate (sum)
  functions.

410
  Used for duplicating lists in processing queries with temporary
411
  tables.
412
*/
413
Item::Item(THD *thd, Item *item):
414
  rsize(0),
415 416
  str_value(item->str_value),
  name(item->name),
417
  orig_name(item->orig_name),
418 419 420 421 422 423 424 425
  max_length(item->max_length),
  marker(item->marker),
  decimals(item->decimals),
  maybe_null(item->maybe_null),
  null_value(item->null_value),
  unsigned_flag(item->unsigned_flag),
  with_sum_func(item->with_sum_func),
  fixed(item->fixed),
426 427
  collation(item->collation),
  cmp_context(item->cmp_context)
428
{
429 430
  next= thd->free_list;				// Put in free list
  thd->free_list= this;
431 432
}

433

434 435 436 437 438 439 440 441 442 443 444
uint Item::decimal_precision() const
{
  Item_result restype= result_type();

  if ((restype == DECIMAL_RESULT) || (restype == INT_RESULT))
    return min(my_decimal_length_to_precision(max_length, decimals, unsigned_flag),
               DECIMAL_MAX_PRECISION);
  return min(max_length, DECIMAL_MAX_PRECISION);
}


445
void Item::print_item_w_name(String *str, enum_query_type query_type)
446
{
447 448
  print(str, query_type);

449 450
  if (name)
  {
451
    THD *thd= current_thd;
452
    str->append(STRING_WITH_LEN(" AS "));
453
    append_identifier(thd, str, name, (uint) strlen(name));
454 455 456 457
  }
}


458 459 460 461
void Item::cleanup()
{
  DBUG_ENTER("Item::cleanup");
  fixed=0;
462
  marker= 0;
463 464
  if (orig_name)
    name= orig_name;
465 466 467
  DBUG_VOID_RETURN;
}

468

469 470
/**
  cleanup() item if it is 'fixed'.
471

472
  @param arg   a dummy parameter, is not used here
473 474
*/

475
bool Item::cleanup_processor(uchar *arg)
476 477 478 479 480 481 482
{
  if (fixed)
    cleanup();
  return FALSE;
}


483 484
/**
  rename item (used for views, cleanup() return original name).
485

486
  @param new_name	new name of item;
487 488 489 490 491
*/

void Item::rename(char *new_name)
{
  /*
492
    we can compare pointers to names here, because if name was not changed,
493 494 495 496 497 498 499 500
    pointer will be same
  */
  if (!orig_name && new_name != name)
    orig_name= name;
  name= new_name;
}


501
/**
502
  Traverse item tree possibly transforming it (replacing items).
503

504 505 506 507
  This function is designed to ease transformation of Item trees.
  Re-execution note: every such transformation is registered for
  rollback by THD::change_item_tree() and is rolled back at the end
  of execution by THD::rollback_item_tree_changes().
508

509 510 511 512 513 514 515
  Therefore:
  - this function can not be used at prepared statement prepare
  (in particular, in fix_fields!), as only permanent
  transformation of Item trees are allowed at prepare.
  - the transformer function shall allocate new Items in execution
  memory root (thd->mem_root) and not anywhere else: allocated
  items will be gone in the end of execution.
516

517 518
  If you don't need to transform an item tree, but only traverse
  it, please use Item::walk() instead.
519 520


521 522
  @param transformer    functor that performs transformation of a subtree
  @param arg            opaque argument passed to the functor
523

524
  @return
525
    Returns pointer to the new subtree root.  THD::change_item_tree()
526
    should be called for it if transformation took place, i.e. if a
527 528 529
    pointer to newly allocated item is returned.
*/

530
Item* Item::transform(Item_transformer transformer, uchar *arg)
531 532 533 534 535 536 537
{
  DBUG_ASSERT(!current_thd->is_stmt_prepare());

  return (this->*transformer)(arg);
}


538 539 540 541 542 543 544
Item_ident::Item_ident(Name_resolution_context *context_arg,
                       const char *db_name_arg,const char *table_name_arg,
		       const char *field_name_arg)
  :orig_db_name(db_name_arg), orig_table_name(table_name_arg),
   orig_field_name(field_name_arg), context(context_arg),
   db_name(db_name_arg), table_name(table_name_arg),
   field_name(field_name_arg),
545
   alias_name_used(FALSE), cached_field_index(NO_CACHED_FIELD_INDEX),
546
   cached_table(0), depended_from(0)
monty@mysql.com's avatar
monty@mysql.com committed
547
{
548
  name = (char*) field_name_arg;
monty@mysql.com's avatar
monty@mysql.com committed
549 550
}

551

552 553 554
/**
  Constructor used by Item_field & Item_*_ref (see Item comment)
*/
555

556 557
Item_ident::Item_ident(THD *thd, Item_ident *item)
  :Item(thd, item),
558 559 560
   orig_db_name(item->orig_db_name),
   orig_table_name(item->orig_table_name), 
   orig_field_name(item->orig_field_name),
561
   context(item->context),
562 563 564
   db_name(item->db_name),
   table_name(item->table_name),
   field_name(item->field_name),
565
   alias_name_used(item->alias_name_used),
566
   cached_field_index(item->cached_field_index),
567
   cached_table(item->cached_table),
568
   depended_from(item->depended_from)
569
{}
570

571 572
void Item_ident::cleanup()
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
573
  DBUG_ENTER("Item_ident::cleanup");
monty@mysql.com's avatar
monty@mysql.com committed
574
#ifdef CANT_BE_USED_AS_MEMORY_IS_FREED
575 576 577 578 579 580
		       db_name ? db_name : "(null)",
                       orig_db_name ? orig_db_name : "(null)",
		       table_name ? table_name : "(null)",
                       orig_table_name ? orig_table_name : "(null)",
		       field_name ? field_name : "(null)",
                       orig_field_name ? orig_field_name : "(null)"));
monty@mysql.com's avatar
monty@mysql.com committed
581
#endif
582
  Item::cleanup();
583 584 585
  db_name= orig_db_name; 
  table_name= orig_table_name;
  field_name= orig_field_name;
586
  depended_from= 0;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
587
  DBUG_VOID_RETURN;
588 589
}

590
bool Item_ident::remove_dependence_processor(uchar * arg)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
591 592 593 594
{
  DBUG_ENTER("Item_ident::remove_dependence_processor");
  if (depended_from == (st_select_lex *) arg)
    depended_from= 0;
595
  DBUG_RETURN(0);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
596 597 598
}


599
/**
600 601
  Store the pointer to this item field into a list if not already there.

602 603
  The method is used by Item::walk to collect all unique Item_field objects
  from a tree of Items into a set of items represented as a list.
604

605 606 607 608
  Item_cond::walk() and Item_func::walk() stop the evaluation of the
  processor function for its arguments once the processor returns
  true.Therefore in order to force this method being called for all item
  arguments in a condition the method must return false.
609

610
  @param arg  pointer to a List<Item_field>
611

612
  @return
timour@mysql.com's avatar
timour@mysql.com committed
613
    FALSE to force the evaluation of collect_item_field_processor
614
    for the subsequent items.
615 616
*/

617
bool Item_field::collect_item_field_processor(uchar *arg)
618 619 620 621 622 623 624 625 626
{
  DBUG_ENTER("Item_field::collect_item_field_processor");
  DBUG_PRINT("info", ("%s", field->field_name ? field->field_name : "noname"));
  List<Item_field> *item_list= (List<Item_field>*) arg;
  List_iterator<Item_field> item_list_it(*item_list);
  Item_field *curr_item;
  while ((curr_item= item_list_it++))
  {
    if (curr_item->eq(this, 1))
627
      DBUG_RETURN(FALSE); /* Already in the set. */
628 629
  }
  item_list->push_back(this);
630
  DBUG_RETURN(FALSE);
631 632 633
}


634
/**
timour@mysql.com's avatar
timour@mysql.com committed
635 636
  Check if an Item_field references some field from a list of fields.

637 638 639 640
  Check whether the Item_field represented by 'this' references any
  of the fields in the keyparts passed via 'arg'. Used with the
  method Item::walk() to test whether any keypart in a sequence of
  keyparts is referenced in an expression.
timour@mysql.com's avatar
timour@mysql.com committed
641

642
  @param arg   Field being compared, arg must be of type Field
timour@mysql.com's avatar
timour@mysql.com committed
643

644
  @retval
timour@mysql.com's avatar
timour@mysql.com committed
645
    TRUE  if 'this' references the field 'arg'
646
  @retval
timour@mysql.com's avatar
timour@mysql.com committed
647
    FALSE otherwise
timour@mysql.com's avatar
timour@mysql.com committed
648
*/
timour@mysql.com's avatar
timour@mysql.com committed
649

650
bool Item_field::find_item_in_field_list_processor(uchar *arg)
timour@mysql.com's avatar
timour@mysql.com committed
651 652 653 654 655 656 657 658 659 660 661 662 663 664
{
  KEY_PART_INFO *first_non_group_part= *((KEY_PART_INFO **) arg);
  KEY_PART_INFO *last_part= *(((KEY_PART_INFO **) arg) + 1);
  KEY_PART_INFO *cur_part;

  for (cur_part= first_non_group_part; cur_part != last_part; cur_part++)
  {
    if (field->eq(cur_part->field))
      return TRUE;
  }
  return FALSE;
}


665 666 667 668 669 670 671 672
/*
  Mark field in read_map

  NOTES
    This is used by filesort to register used fields in a a temporary
    column read set or to register used fields in a view
*/

673
bool Item_field::register_field_in_read_map(uchar *arg)
674 675 676 677 678 679 680 681
{
  TABLE *table= (TABLE *) arg;
  if (field->table == table || !table)
    bitmap_set_bit(field->table->read_set, field->field_index);
  return 0;
}


682 683 684 685
bool Item::check_cols(uint c)
{
  if (c != 1)
  {
686
    my_error(ER_OPERAND_COLUMNS, MYF(0), c);
687 688 689 690 691
    return 1;
  }
  return 0;
}

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
692 693

void Item::set_name(const char *str, uint length, CHARSET_INFO *cs)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
694 695 696
{
  if (!length)
  {
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
697 698
    /* Empty string, used by AS or internal function like last_insert_id() */
    name= (char*) str;
699
    name_length= 0;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
700 701
    return;
  }
702 703
  if (cs->ctype)
  {
704
    uint orig_len= length;
monty@mysql.com's avatar
monty@mysql.com committed
705 706 707 708
    /*
      This will probably need a better implementation in the future:
      a function in CHARSET_INFO structure.
    */
709 710 711 712 713
    while (length && !my_isgraph(cs,*str))
    {						// Fix problem with yacc
      length--;
      str++;
    }
714
    if (orig_len != length && !is_autogenerated_name)
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
715 716 717 718 719 720 721 722 723 724
    {
      if (length == 0)
        push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                            ER_NAME_BECOMES_EMPTY, ER(ER_NAME_BECOMES_EMPTY),
                            str + length - orig_len);
      else
        push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                            ER_REMOVED_SPACES, ER(ER_REMOVED_SPACES),
                            str + length - orig_len);
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
725
  }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
726 727
  if (!my_charset_same(cs, system_charset_info))
  {
728
    size_t res_length;
729
    name= sql_strmake_with_convert(str, name_length= length, cs,
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
730 731 732 733
				   MAX_ALIAS_NAME, system_charset_info,
				   &res_length);
  }
  else
734
    name= sql_strmake(str, (name_length= min(length,MAX_ALIAS_NAME)));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
735 736
}

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

738 739
/**
  @details
740 741 742
  This function is called when:
  - Comparing items in the WHERE clause (when doing where optimization)
  - When trying to find an ORDER BY/GROUP BY item in the SELECT part
743 744 745
*/

bool Item::eq(const Item *item, bool binary_cmp) const
bk@work.mysql.com's avatar
bk@work.mysql.com committed
746
{
747 748 749 750 751
  /*
    Note, that this is never TRUE if item is a Item_param:
    for all basic constants we have special checks, and Item_param's
    type() can be only among basic constant types.
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
752
  return type() == item->type() && name && item->name &&
753
    !my_strcasecmp(system_charset_info,name,item->name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
754 755
}

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

757 758
Item *Item::safe_charset_converter(CHARSET_INFO *tocs)
{
759 760
  Item_func_conv_charset *conv= new Item_func_conv_charset(this, tocs, 1);
  return conv->safe ? conv : NULL;
761 762 763
}


764 765
/**
  @details
bar@mysql.com's avatar
bar@mysql.com committed
766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783
  Created mostly for mysql_prepare_table(). Important
  when a string ENUM/SET column is described with a numeric default value:

  CREATE TABLE t1(a SET('a') DEFAULT 1);

  We cannot use generic Item::safe_charset_converter(), because
  the latter returns a non-fixed Item, so val_str() crashes afterwards.
  Override Item_num method, to return a fixed item.
*/
Item *Item_num::safe_charset_converter(CHARSET_INFO *tocs)
{
  Item_string *conv;
  char buf[64];
  String *s, tmp(buf, sizeof(buf), &my_charset_bin);
  s= val_str(&tmp);
  if ((conv= new Item_string(s->ptr(), s->length(), s->charset())))
  {
    conv->str_value.copy();
784
    conv->str_value.mark_as_const();
bar@mysql.com's avatar
bar@mysql.com committed
785 786 787 788 789
  }
  return conv;
}


790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
Item *Item_static_float_func::safe_charset_converter(CHARSET_INFO *tocs)
{
  Item_string *conv;
  char buf[64];
  String *s, tmp(buf, sizeof(buf), &my_charset_bin);
  s= val_str(&tmp);
  if ((conv= new Item_static_string_func(func_name, s->ptr(), s->length(),
                                         s->charset())))
  {
    conv->str_value.copy();
    conv->str_value.mark_as_const();
  }
  return conv;
}


806 807 808 809
Item *Item_string::safe_charset_converter(CHARSET_INFO *tocs)
{
  Item_string *conv;
  uint conv_errors;
810
  char *ptr;
811 812 813 814 815 816 817 818 819 820 821 822 823 824
  String tmp, cstr, *ostr= val_str(&tmp);
  cstr.copy(ostr->ptr(), ostr->length(), ostr->charset(), tocs, &conv_errors);
  if (conv_errors || !(conv= new Item_string(cstr.ptr(), cstr.length(),
                                             cstr.charset(),
                                             collation.derivation)))
  {
    /*
      Safe conversion is not possible (or EOM).
      We could not convert a string into the requested character set
      without data loss. The target charset does not cover all the
      characters from the string. Operation cannot be done correctly.
    */
    return NULL;
  }
825
  if (!(ptr= current_thd->strmake(cstr.ptr(), cstr.length())))
826 827
    return NULL;
  conv->str_value.set(ptr, cstr.length(), cstr.charset());
828 829
  /* Ensure that no one is going to change the result string */
  conv->str_value.mark_as_const();
830 831 832 833
  return conv;
}


834 835 836 837 838
Item *Item_param::safe_charset_converter(CHARSET_INFO *tocs)
{
  if (const_item())
  {
    uint cnv_errors;
bar@mysql.com's avatar
bar@mysql.com committed
839 840 841 842 843 844 845 846
    String *ostr= val_str(&cnvstr);
    cnvitem->str_value.copy(ostr->ptr(), ostr->length(),
                            ostr->charset(), tocs, &cnv_errors);
    if (cnv_errors)
       return NULL;
    cnvitem->str_value.mark_as_const();
    cnvitem->max_length= cnvitem->str_value.numchars() * tocs->mbmaxlen;
    return cnvitem;
847 848 849 850 851
  }
  return NULL;
}


852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
Item *Item_static_string_func::safe_charset_converter(CHARSET_INFO *tocs)
{
  Item_string *conv;
  uint conv_errors;
  String tmp, cstr, *ostr= val_str(&tmp);
  cstr.copy(ostr->ptr(), ostr->length(), ostr->charset(), tocs, &conv_errors);
  if (conv_errors ||
      !(conv= new Item_static_string_func(func_name,
                                          cstr.ptr(), cstr.length(),
                                          cstr.charset(),
                                          collation.derivation)))
  {
    /*
      Safe conversion is not possible (or EOM).
      We could not convert a string into the requested character set
      without data loss. The target charset does not cover all the
      characters from the string. Operation cannot be done correctly.
869 870 871 872
    */
    return NULL;
  }
  conv->str_value.copy();
873 874
  /* Ensure that no one is going to change the result string */
  conv->str_value.mark_as_const();
875 876 877 878
  return conv;
}


879 880
bool Item_string::eq(const Item *item, bool binary_cmp) const
{
881
  if (type() == item->type() && item->basic_const_item())
882 883
  {
    if (binary_cmp)
monty@mysql.com's avatar
monty@mysql.com committed
884
      return !stringcmp(&str_value, &item->str_value);
885 886
    return (collation.collation == item->collation.collation &&
	    !sortcmp(&str_value, &item->str_value, collation.collation));
887 888 889 890 891
  }
  return 0;
}


892
/**
893
  Get the value of the function as a MYSQL_TIME structure.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
894
  As a extra convenience the time structure is reset on error!
895
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
896

897
bool Item::get_date(MYSQL_TIME *ltime,uint fuzzydate)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
898
{
899
  if (result_type() == STRING_RESULT)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
900
  {
901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920
    char buff[40];
    String tmp(buff,sizeof(buff), &my_charset_bin),*res;
    if (!(res=val_str(&tmp)) ||
        str_to_datetime_with_warn(res->ptr(), res->length(),
                                  ltime, fuzzydate) <= MYSQL_TIMESTAMP_ERROR)
      goto err;
  }
  else
  {
    longlong value= val_int();
    int was_cut;
    if (number_to_datetime(value, ltime, fuzzydate, &was_cut) == LL(-1))
    {
      char buff[22], *end;
      end= longlong10_to_str(value, buff, -10);
      make_truncated_value_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                                   buff, (int) (end-buff), MYSQL_TIMESTAMP_NONE,
                                   NullS);
      goto err;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
921 922
  }
  return 0;
923 924 925 926

err:
  bzero((char*) ltime,sizeof(*ltime));
  return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
927 928
}

929 930 931
/**
  Get time of first argument.\

bk@work.mysql.com's avatar
bk@work.mysql.com committed
932
  As a extra convenience the time structure is reset on error!
933
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
934

935
bool Item::get_time(MYSQL_TIME *ltime)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
936 937
{
  char buff[40];
938
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
939
  if (!(res=val_str(&tmp)) ||
940
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
941 942 943 944 945 946 947
  {
    bzero((char*) ltime,sizeof(*ltime));
    return 1;
  }
  return 0;
}

948
CHARSET_INFO *Item::default_charset()
949
{
950
  return current_thd->variables.collation_connection;
951 952
}

953

954 955 956 957 958 959 960 961
/*
  Save value in field, but don't give any warnings

  NOTES
   This is used to temporary store and retrieve a value in a column,
   for example in opt_range to adjust the key value to fit the column.
*/

962 963 964
int Item::save_in_field_no_warnings(Field *field, bool no_conversions)
{
  int res;
965 966
  TABLE *table= field->table;
  THD *thd= table->in_use;
967
  enum_check_fields tmp= thd->count_cuted_fields;
968
  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->write_set);
969 970
  ulong sql_mode= thd->variables.sql_mode;
  thd->variables.sql_mode&= ~(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE);
971 972 973
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
  res= save_in_field(field, no_conversions);
  thd->count_cuted_fields= tmp;
974
  dbug_tmp_restore_column_map(table->write_set, old_map);
975
  thd->variables.sql_mode= sql_mode;
976 977 978 979
  return res;
}


980
/*****************************************************************************
981
  Item_sp_variable methods
982
*****************************************************************************/
983 984 985 986 987 988 989 990 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

Item_sp_variable::Item_sp_variable(char *sp_var_name_str,
                                   uint sp_var_name_length)
  :m_thd(0)
#ifndef DBUG_OFF
   , m_sp(0)
#endif
{
  m_name.str= sp_var_name_str;
  m_name.length= sp_var_name_length;
}


bool Item_sp_variable::fix_fields(THD *thd, Item **)
{
  Item *it;

  m_thd= thd; /* NOTE: this must be set before any this_xxx() */
  it= this_item();

  DBUG_ASSERT(it->fixed);

  max_length= it->max_length;
  decimals= it->decimals;
  unsigned_flag= it->unsigned_flag;
  fixed= 1;
  collation.set(it->collation.collation, it->collation.derivation);

  return FALSE;
}


double Item_sp_variable::val_real()
1016 1017 1018 1019
{
  DBUG_ASSERT(fixed);
  Item *it= this_item();
  double ret= it->val_real();
1020
  null_value= it->null_value;
1021 1022 1023 1024
  return ret;
}


1025
longlong Item_sp_variable::val_int()
1026 1027 1028 1029
{
  DBUG_ASSERT(fixed);
  Item *it= this_item();
  longlong ret= it->val_int();
1030
  null_value= it->null_value;
1031 1032 1033 1034
  return ret;
}


1035
String *Item_sp_variable::val_str(String *sp)
1036 1037 1038
{
  DBUG_ASSERT(fixed);
  Item *it= this_item();
1039
  String *res= it->val_str(sp);
1040 1041

  null_value= it->null_value;
1042

1043 1044 1045
  if (!res)
    return NULL;

1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
  /*
    This way we mark returned value of val_str as const,
    so that various functions (e.g. CONCAT) won't try to
    modify the value of the Item. Analogous mechanism is
    implemented for Item_param.
    Without this trick Item_splocal could be changed as a
    side-effect of expression computation. Here is an example
    of what happens without it: suppose x is varchar local
    variable in a SP with initial value 'ab' Then
      select concat(x,'c');
    would change x's value to 'abc', as Item_func_concat::val_str()
    would use x's internal buffer to compute the result.
    This is intended behaviour of Item_func_concat. Comments to
    Item_param class contain some more details on the topic.
  */
1061

1062 1063 1064 1065
  if (res != &str_value)
    str_value.set(res->ptr(), res->length(), res->charset());
  else
    res->mark_as_const();
1066

1067
  return &str_value;
1068 1069 1070
}


1071
my_decimal *Item_sp_variable::val_decimal(my_decimal *decimal_value)
1072 1073 1074
{
  DBUG_ASSERT(fixed);
  Item *it= this_item();
1075
  my_decimal *val= it->val_decimal(decimal_value);
1076
  null_value= it->null_value;
1077 1078 1079 1080
  return val;
}


1081
bool Item_sp_variable::is_null()
1082
{
1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
  return this_item()->is_null();
}


/*****************************************************************************
  Item_splocal methods
*****************************************************************************/

Item_splocal::Item_splocal(const LEX_STRING &sp_var_name,
                           uint sp_var_idx,
                           enum_field_types sp_var_type,
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
1094
                           uint pos_in_q, uint len_in_q)
1095
  :Item_sp_variable(sp_var_name.str, sp_var_name.length),
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
1096
   m_var_idx(sp_var_idx), pos_in_query(pos_in_q), len_in_query(len_in_q)
1097 1098 1099 1100
{
  maybe_null= TRUE;

  m_type= sp_map_item_type(sp_var_type);
1101
  m_field_type= sp_var_type;
1102
  m_result_type= sp_map_result_type(sp_var_type);
1103 1104 1105
}


1106 1107 1108
Item *
Item_splocal::this_item()
{
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
  DBUG_ASSERT(m_sp == m_thd->spcont->sp);

  return m_thd->spcont->get_item(m_var_idx);
}

const Item *
Item_splocal::this_item() const
{
  DBUG_ASSERT(m_sp == m_thd->spcont->sp);

  return m_thd->spcont->get_item(m_var_idx);
1120 1121
}

1122 1123

Item **
1124
Item_splocal::this_item_addr(THD *thd, Item **)
1125
{
1126 1127 1128
  DBUG_ASSERT(m_sp == thd->spcont->sp);

  return thd->spcont->get_item_addr(m_var_idx);
1129 1130
}

1131

1132
void Item_splocal::print(String *str, enum_query_type)
1133
{
1134 1135 1136 1137
  str->reserve(m_name.length+8);
  str->append(m_name.str, m_name.length);
  str->append('@');
  str->qs_append(m_var_idx);
1138 1139
}

1140

1141
bool Item_splocal::set_value(THD *thd, sp_rcontext *ctx, Item **it)
1142 1143 1144 1145 1146
{
  return ctx->set_variable(thd, get_var_idx(), it);
}


1147 1148 1149 1150
/*****************************************************************************
  Item_case_expr methods
*****************************************************************************/

1151
Item_case_expr::Item_case_expr(uint case_expr_id)
andrey@example.com's avatar
andrey@example.com committed
1152
  :Item_sp_variable( C_STRING_WITH_LEN("case_expr")),
1153
   m_case_expr_id(case_expr_id)
1154 1155 1156 1157
{
}


1158 1159
Item *
Item_case_expr::this_item()
1160
{
1161 1162 1163
  DBUG_ASSERT(m_sp == m_thd->spcont->sp);

  return m_thd->spcont->get_case_expr(m_case_expr_id);
1164 1165 1166
}


1167 1168 1169

const Item *
Item_case_expr::this_item() const
1170
{
1171 1172 1173
  DBUG_ASSERT(m_sp == m_thd->spcont->sp);

  return m_thd->spcont->get_case_expr(m_case_expr_id);
1174 1175 1176
}


1177 1178
Item **
Item_case_expr::this_item_addr(THD *thd, Item **)
1179
{
1180 1181 1182 1183 1184 1185
  DBUG_ASSERT(m_sp == thd->spcont->sp);

  return thd->spcont->get_case_expr_addr(m_case_expr_id);
}


1186
void Item_case_expr::print(String *str, enum_query_type)
1187
{
1188 1189
  if (str->reserve(MAX_INT_WIDTH + sizeof("case_expr@")))
    return;                                    /* purecov: inspected */
serg@serg.mylan's avatar
serg@serg.mylan committed
1190
  VOID(str->append(STRING_WITH_LEN("case_expr@")));
1191
  str->qs_append(m_case_expr_id);
1192 1193 1194
}


1195 1196 1197
/*****************************************************************************
  Item_name_const methods
*****************************************************************************/
1198

1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229
double Item_name_const::val_real()
{
  DBUG_ASSERT(fixed);
  double ret= value_item->val_real();
  null_value= value_item->null_value;
  return ret;
}


longlong Item_name_const::val_int()
{
  DBUG_ASSERT(fixed);
  longlong ret= value_item->val_int();
  null_value= value_item->null_value;
  return ret;
}


String *Item_name_const::val_str(String *sp)
{
  DBUG_ASSERT(fixed);
  String *ret= value_item->val_str(sp);
  null_value= value_item->null_value;
  return ret;
}


my_decimal *Item_name_const::val_decimal(my_decimal *decimal_value)
{
  DBUG_ASSERT(fixed);
  my_decimal *val= value_item->val_decimal(decimal_value);
1230
  null_value= value_item->null_value;
1231 1232 1233 1234 1235 1236
  return val;
}


bool Item_name_const::is_null()
{
1237
  return value_item->is_null();
1238 1239 1240 1241
}

Item::Type Item_name_const::type() const
{
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
  /*
    As 
    1. one can try to create the Item_name_const passing non-constant 
    arguments, although it's incorrect and 
    2. the type() method can be called before the fix_fields() to get
    type information for a further type cast, e.g. 
    if (item->type() == FIELD_ITEM) 
      ((Item_field *) item)->... 
    we return NULL_ITEM in the case to avoid wrong casting.
  */
  return valid_args ? value_item->type() : NULL_ITEM;
1253 1254 1255
}


1256
bool Item_name_const::fix_fields(THD *thd, Item **ref)
1257 1258 1259 1260 1261 1262 1263
{
  char buf[128];
  String *item_name;
  String s(buf, sizeof(buf), &my_charset_bin);
  s.length(0);

  if (value_item->fix_fields(thd, &value_item) ||
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
1264 1265 1266 1267 1268 1269
      name_item->fix_fields(thd, &name_item) ||
      !value_item->const_item() ||
      !name_item->const_item() ||
      !(item_name= name_item->val_str(&s))) // Can't have a NULL name 
  {
    my_error(ER_RESERVED_SYNTAX, MYF(0), "NAME_CONST");
1270
    return TRUE;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
1271
  }
1272 1273 1274 1275 1276 1277 1278 1279
  set_name(item_name->ptr(), (uint) item_name->length(), system_charset_info);
  max_length= value_item->max_length;
  decimals= value_item->decimals;
  fixed= 1;
  return FALSE;
}


1280
void Item_name_const::print(String *str, enum_query_type query_type)
1281
{
1282
  str->append(STRING_WITH_LEN("NAME_CONST("));
1283
  name_item->print(str, query_type);
1284
  str->append(',');
1285
  value_item->print(str, query_type);
1286 1287 1288
  str->append(')');
}

1289

1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
/*
 need a special class to adjust printing : references to aggregate functions 
 must not be printed as refs because the aggregate functions that are added to
 the front of select list are not printed as well.
*/
class Item_aggregate_ref : public Item_ref
{
public:
  Item_aggregate_ref(Name_resolution_context *context_arg, Item **item,
                  const char *table_name_arg, const char *field_name_arg)
    :Item_ref(context_arg, item, table_name_arg, field_name_arg) {}

1302
  virtual inline void print (String *str, enum_query_type query_type)
1303 1304
  {
    if (ref)
1305
      (*ref)->print(str, query_type);
1306
    else
1307
      Item_ident::print(str, query_type);
1308 1309 1310 1311
  }
};


1312 1313
/**
  Move SUM items out from item tree and replace with reference.
1314

1315 1316 1317 1318 1319 1320
  @param thd			Thread handler
  @param ref_pointer_array	Pointer to array of reference fields
  @param fields		All fields in select
  @param ref			Pointer to item
  @param skip_registered       <=> function be must skipped for registered
                               SUM items
1321

1322 1323
  @note
    This is from split_sum_func2() for items that should be split
1324

1325 1326
    All found SUM items are added FIRST in the fields list and
    we replace the item with a reference.
1327

1328
    thd->fatal_error() may be called if we are out of memory
1329 1330 1331
*/

void Item::split_sum_func2(THD *thd, Item **ref_pointer_array,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1332 1333
                           List<Item> &fields, Item **ref, 
                           bool skip_registered)
1334
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1335 1336 1337 1338
  /* An item of type Item_sum  is registered <=> ref_by != 0 */ 
  if (type() == SUM_FUNC_ITEM && skip_registered && 
      ((Item_sum *) this)->ref_by)
    return;                                                 
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
1339 1340 1341 1342
  if ((type() != SUM_FUNC_ITEM && with_sum_func) ||
      (type() == FUNC_ITEM &&
       (((Item_func *) this)->functype() == Item_func::ISNOTNULLTEST_FUNC ||
        ((Item_func *) this)->functype() == Item_func::TRIG_COND_FUNC)))
1343 1344 1345 1346
  {
    /* Will split complicated items and ignore simple ones */
    split_sum_func(thd, ref_pointer_array, fields);
  }
1347
  else if ((type() == SUM_FUNC_ITEM || (used_tables() & ~PARAM_TABLE_BIT)) &&
1348
           type() != SUBSELECT_ITEM &&
1349 1350
           (type() != REF_ITEM ||
           ((Item_ref*)this)->ref_type() == Item_ref::VIEW_REF))
1351 1352 1353 1354 1355 1356 1357 1358
  {
    /*
      Replace item with a reference so that we can easily calculate
      it (in case of sum functions) or copy it (in case of fields)

      The test above is to ensure we don't do a reference for things
      that are constants (PARAM_TABLE_BIT is in effect a constant)
      or already referenced (for example an item in HAVING)
1359 1360
      Exception is Item_direct_view_ref which we need to convert to
      Item_ref to allow fields from view being stored in tmp table.
1361
    */
1362
    Item_aggregate_ref *item_ref;
1363
    uint el= fields.elements;
1364
    Item *real_itm= real_item();
1365

evgen@moonbone.local's avatar
evgen@moonbone.local committed
1366
    ref_pointer_array[el]= real_itm;
1367
    if (!(item_ref= new Item_aggregate_ref(&thd->lex->current_select->context,
1368
                                           ref_pointer_array + el, 0, name)))
1369
      return;                                   // fatal_error is set
1370 1371
    if (type() == SUM_FUNC_ITEM)
      item_ref->depended_from= ((Item_sum *) this)->depended_from(); 
evgen@moonbone.local's avatar
evgen@moonbone.local committed
1372
    fields.push_front(real_itm);
1373
    thd->change_item_tree(ref, item_ref);
1374 1375 1376 1377
  }
}


1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396
static bool
left_is_superset(DTCollation *left, DTCollation *right)
{
  /* Allow convert to Unicode */
  if (left->collation->state & MY_CS_UNICODE &&
      (left->derivation < right->derivation ||
       (left->derivation == right->derivation &&
        !(right->collation->state & MY_CS_UNICODE))))
    return TRUE;
  /* Allow convert from ASCII */
  if (right->repertoire == MY_REPERTOIRE_ASCII &&
      (left->derivation < right->derivation ||
       (left->derivation == right->derivation &&
        !(left->repertoire == MY_REPERTOIRE_ASCII))))
    return TRUE;
  /* Disallow conversion otherwise */
  return FALSE;
}

1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430
/**
  Aggregate two collations together taking
  into account their coercibility (aka derivation):.

  0 == DERIVATION_EXPLICIT  - an explicitly written COLLATE clause @n
  1 == DERIVATION_NONE      - a mix of two different collations @n
  2 == DERIVATION_IMPLICIT  - a column @n
  3 == DERIVATION_COERCIBLE - a string constant.

  The most important rules are:
  -# If collations are the same:
  chose this collation, and the strongest derivation.
  -# If collations are different:
  - Character sets may differ, but only if conversion without
  data loss is possible. The caller provides flags whether
  character set conversion attempts should be done. If no
  flags are substituted, then the character sets must be the same.
  Currently processed flags are:
  MY_COLL_ALLOW_SUPERSET_CONV  - allow conversion to a superset
  MY_COLL_ALLOW_COERCIBLE_CONV - allow conversion of a coercible value
  - two EXPLICIT collations produce an error, e.g. this is wrong:
  CONCAT(expr1 collate latin1_swedish_ci, expr2 collate latin1_german_ci)
  - the side with smaller derivation value wins,
  i.e. a column is stronger than a string constant,
  an explicit COLLATE clause is stronger than a column.
  - if derivations are the same, we have DERIVATION_NONE,
  we'll wait for an explicit COLLATE clause which possibly can
  come from another argument later: for example, this is valid,
  but we don't know yet when collecting the first two arguments:
     @code
       CONCAT(latin1_swedish_ci_column,
              latin1_german1_ci_column,
              expr COLLATE latin1_german2_ci)
  @endcode
1431
*/
1432

1433
bool DTCollation::aggregate(DTCollation &dt, uint flags)
1434
{
1435
  if (!my_charset_same(collation, dt.collation))
1436
  {
1437 1438 1439
    /* 
       We do allow to use binary strings (like BLOBS)
       together with character strings.
1440
       Binaries have more precedence than a character
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1441
       string of the same derivation.
1442
    */
1443
    if (collation == &my_charset_bin)
1444
    {
1445 1446 1447
      if (derivation <= dt.derivation)
	; // Do nothing
      else
1448 1449 1450
      {
	set(dt); 
      }
1451
    }
1452
    else if (dt.collation == &my_charset_bin)
1453
    {
1454
      if (dt.derivation <= derivation)
1455
      {
1456
        set(dt);
1457
      }
1458
      else
1459 1460 1461
      {
        // Do nothing
      }
1462
    }
1463
    else if ((flags & MY_COLL_ALLOW_SUPERSET_CONV) &&
1464
             left_is_superset(this, &dt))
1465
    {
1466 1467 1468
      // Do nothing
    }
    else if ((flags & MY_COLL_ALLOW_SUPERSET_CONV) &&
1469
             left_is_superset(&dt, this))
1470 1471 1472 1473 1474
    {
      set(dt);
    }
    else if ((flags & MY_COLL_ALLOW_COERCIBLE_CONV) &&
             derivation < dt.derivation &&
1475
             dt.derivation >= DERIVATION_SYSCONST)
1476 1477 1478 1479 1480
    {
      // Do nothing;
    }
    else if ((flags & MY_COLL_ALLOW_COERCIBLE_CONV) &&
             dt.derivation < derivation &&
1481
             derivation >= DERIVATION_SYSCONST)
1482 1483
    {
      set(dt);
1484
    }
1485 1486
    else
    {
1487
      // Cannot apply conversion
1488
      set(0, DERIVATION_NONE, 0);
1489
      return 1;
1490
    }
1491
  }
1492
  else if (derivation < dt.derivation)
1493
  {
1494
    // Do nothing
1495
  }
1496
  else if (dt.derivation < derivation)
1497
  {
1498
    set(dt);
1499
  }
1500 1501 1502
  else
  { 
    if (collation == dt.collation)
1503
    {
1504 1505 1506 1507 1508
      // Do nothing
    }
    else 
    {
      if (derivation == DERIVATION_EXPLICIT)
1509
      {
1510 1511
        set(0, DERIVATION_NONE, 0);
        return 1;
1512
      }
1513 1514
      if (collation->state & MY_CS_BINSORT)
        return 0;
1515
      if (dt.collation->state & MY_CS_BINSORT)
1516 1517 1518 1519
      {
        set(dt);
        return 0;
      }
1520
      CHARSET_INFO *bin= get_charset_by_csname(collation->csname, 
1521
                                               MY_CS_BINSORT,MYF(0));
1522
      set(bin, DERIVATION_NONE);
1523
    }
1524
  }
1525
  repertoire|= dt.repertoire;
1526 1527 1528
  return 0;
}

1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
/******************************/
static
void my_coll_agg_error(DTCollation &c1, DTCollation &c2, const char *fname)
{
  my_error(ER_CANT_AGGREGATE_2COLLATIONS,MYF(0),
           c1.collation->name,c1.derivation_name(),
           c2.collation->name,c2.derivation_name(),
           fname);
}


static
void my_coll_agg_error(DTCollation &c1, DTCollation &c2, DTCollation &c3,
                       const char *fname)
{
  my_error(ER_CANT_AGGREGATE_3COLLATIONS,MYF(0),
  	   c1.collation->name,c1.derivation_name(),
	   c2.collation->name,c2.derivation_name(),
	   c3.collation->name,c3.derivation_name(),
	   fname);
}


static
1553 1554
void my_coll_agg_error(Item** args, uint count, const char *fname,
                       int item_sep)
1555 1556
{
  if (count == 2)
1557
    my_coll_agg_error(args[0]->collation, args[item_sep]->collation, fname);
1558
  else if (count == 3)
1559 1560
    my_coll_agg_error(args[0]->collation, args[item_sep]->collation,
                      args[2*item_sep]->collation, fname);
1561 1562 1563 1564 1565 1566
  else
    my_error(ER_CANT_AGGREGATE_NCOLLATIONS,MYF(0),fname);
}


bool agg_item_collations(DTCollation &c, const char *fname,
1567
                         Item **av, uint count, uint flags, int item_sep)
1568 1569
{
  uint i;
1570
  Item **arg;
1571
  c.set(av[0]->collation);
1572
  for (i= 1, arg= &av[item_sep]; i < count; i++, arg++)
1573
  {
1574
    if (c.aggregate((*arg)->collation, flags))
1575
    {
1576
      my_coll_agg_error(av, count, fname, item_sep);
1577 1578 1579 1580 1581 1582
      return TRUE;
    }
  }
  if ((flags & MY_COLL_DISALLOW_NONE) &&
      c.derivation == DERIVATION_NONE)
  {
1583
    my_coll_agg_error(av, count, fname, item_sep);
1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
    return TRUE;
  }
  return FALSE;
}


bool agg_item_collations_for_comparison(DTCollation &c, const char *fname,
                                        Item **av, uint count, uint flags)
{
  return (agg_item_collations(c, fname, av, count,
1594
                              flags | MY_COLL_DISALLOW_NONE, 1));
1595 1596 1597
}


1598
/**
1599
  Collect arguments' character sets together.
1600

1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
  We allow to apply automatic character set conversion in some cases.
  The conditions when conversion is possible are:
  - arguments A and B have different charsets
  - A wins according to coercibility rules
    (i.e. a column is stronger than a string constant,
     an explicit COLLATE clause is stronger than a column)
  - character set of A is either superset for character set of B,
    or B is a string constant which can be converted into the
    character set of A without data loss.
    
  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.
  
  For functions with more than two arguments:
1616
  @code
1617
    collect(A,B,C) ::= collect(collect(A,B),C)
1618
  @endcode
1619 1620 1621 1622 1623
  Since this function calls THD::change_item_tree() on the passed Item **
  pointers, it is necessary to pass the original Item **'s, not copies.
  Otherwise their values will not be properly restored (see BUG#20769).
  If the items are not consecutive (eg. args[2] and args[5]), use the
  item_sep argument, ie.
1624
  @code
1625
    agg_item_charsets(coll, fname, &args[2], 2, flags, 3)
1626
  @endcode
1627 1628 1629
*/

bool agg_item_charsets(DTCollation &coll, const char *fname,
1630
                       Item **args, uint nargs, uint flags, int item_sep)
1631
{
1632
  Item **arg, *safe_args[2];
1633 1634 1635

  LINT_INIT(safe_args[0]);
  LINT_INIT(safe_args[1]);
1636

1637
  if (agg_item_collations(coll, fname, args, nargs, flags, item_sep))
1638 1639 1640 1641 1642 1643 1644 1645 1646
    return TRUE;

  /*
    For better error reporting: save the first and the second argument.
    We need this only if the the number of args is 3 or 2:
    - for a longer argument list, "Illegal mix of collations"
      doesn't display each argument's characteristics.
    - if nargs is 1, then this error cannot happen.
  */
1647 1648
  LINT_INIT(safe_args[0]);
  LINT_INIT(safe_args[1]);
1649 1650 1651
  if (nargs >=2 && nargs <= 3)
  {
    safe_args[0]= args[0];
1652
    safe_args[1]= args[item_sep];
1653 1654 1655
  }

  THD *thd= current_thd;
1656
  Query_arena *arena, backup;
1657
  bool res= FALSE;
1658
  uint i;
1659 1660 1661 1662
  /*
    In case we're in statement prepare, create conversion item
    in its memory: it will be reused on each execute.
  */
1663 1664
  arena= thd->is_stmt_prepare() ? thd->activate_stmt_arena_if_needed(&backup)
                                : NULL;
1665

1666
  for (i= 0, arg= args; i < nargs; i++, arg+= item_sep)
1667 1668 1669
  {
    Item* conv;
    uint32 dummy_offset;
1670 1671
    if (!String::needs_conversion(0, (*arg)->collation.collation,
                                  coll.collation,
1672 1673 1674
                                  &dummy_offset))
      continue;

1675 1676 1677 1678 1679
    if (!(conv= (*arg)->safe_charset_converter(coll.collation)) &&
        ((*arg)->collation.repertoire == MY_REPERTOIRE_ASCII))
      conv= new Item_func_conv_charset(*arg, coll.collation, 1);

    if (!conv)
1680 1681 1682 1683 1684
    {
      if (nargs >=2 && nargs <= 3)
      {
        /* restore the original arguments for better error message */
        args[0]= safe_args[0];
1685
        args[item_sep]= safe_args[1];
1686
      }
1687
      my_coll_agg_error(args, nargs, fname, item_sep);
1688 1689 1690
      res= TRUE;
      break; // we cannot return here, we need to restore "arena".
    }
1691 1692
    if ((*arg)->type() == Item::FIELD_ITEM)
      ((Item_field *)(*arg))->no_const_subst= 1;
1693 1694 1695 1696 1697 1698 1699 1700 1701 1702
    /*
      If in statement prepare, then we create a converter for two
      constant items, do it once and then reuse it.
      If we're in execution of a prepared statement, arena is NULL,
      and the conv was created in runtime memory. This can be
      the case only if the argument is a parameter marker ('?'),
      because for all true constants the charset converter has already
      been created in prepare. In this case register the change for
      rollback.
    */
1703
    if (thd->is_stmt_prepare())
1704 1705 1706
      *arg= conv;
    else
      thd->change_item_tree(arg, conv);
1707 1708 1709 1710 1711
    /*
      We do not check conv->fixed, because Item_func_conv_charset which can
      be return by safe_charset_converter can't be fixed at creation
    */
    conv->fix_fields(thd, arg);
1712 1713
  }
  if (arena)
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1714
    thd->restore_active_arena(arena, &backup);
1715 1716 1717 1718
  return res;
}


1719 1720 1721 1722 1723 1724 1725 1726 1727 1728
void Item_ident_for_show::make_field(Send_field *tmp_field)
{
  tmp_field->table_name= tmp_field->org_table_name= table_name;
  tmp_field->db_name= db_name;
  tmp_field->col_name= tmp_field->org_col_name= field->field_name;
  tmp_field->charsetnr= field->charset()->number;
  tmp_field->length=field->field_length;
  tmp_field->type=field->type();
  tmp_field->flags= field->table->maybe_null ? 
    (field->flags & ~NOT_NULL_FLAG) : field->flags;
1729
  tmp_field->decimals= field->decimals();
1730
}
1731 1732 1733

/**********************************************/

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1734
Item_field::Item_field(Field *f)
1735
  :Item_ident(0, NullS, *f->table_name, f->field_name),
1736
   item_equal(0), no_const_subst(0),
1737
   have_privileges(0), any_privileges(0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1738 1739
{
  set_field(f);
1740
  /*
1741
    field_name and table_name should not point to garbage
1742 1743 1744
    if this item is to be reused
  */
  orig_table_name= orig_field_name= "";
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1745 1746
}

1747

1748 1749 1750 1751 1752 1753 1754
/**
  Constructor used inside setup_wild().

  Ensures that field, table, and database names will live as long as
  Item_field (this is important in prepared statements).
*/

1755 1756
Item_field::Item_field(THD *thd, Name_resolution_context *context_arg,
                       Field *f)
1757
  :Item_ident(context_arg, f->table->s->db.str, *f->table_name, f->field_name),
1758
   item_equal(0), no_const_subst(0),
1759
   have_privileges(0), any_privileges(0)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1760
{
1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775
  /*
    We always need to provide Item_field with a fully qualified field
    name to avoid ambiguity when executing prepared statements like
    SELECT * from d1.t1, d2.t1; (assuming d1.t1 and d2.t1 have columns
    with same names).
    This is because prepared statements never deal with wildcards in
    select list ('*') and always fix fields using fully specified path
    (i.e. db.table.column).
    No check for OOM: if db_name is NULL, we'll just get
    "Field not found" error.
    We need to copy db_name, table_name and field_name because they must
    be allocated in the statement memory, not in table memory (the table
    structure can go away and pop up again between subsequent executions
    of a prepared statement).
  */
konstantin@mysql.com's avatar
konstantin@mysql.com committed
1776
  if (thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788
  {
    if (db_name)
      orig_db_name= thd->strdup(db_name);
    orig_table_name= thd->strdup(table_name);
    orig_field_name= thd->strdup(field_name);
    /*
      We don't restore 'name' in cleanup because it's not changed
      during execution. Still we need it to point to persistent
      memory if this item is to be reused.
    */
    name= (char*) orig_field_name;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1789 1790 1791
  set_field(f);
}

1792 1793 1794 1795 1796 1797

Item_field::Item_field(Name_resolution_context *context_arg,
                       const char *db_arg,const char *table_name_arg,
                       const char *field_name_arg)
  :Item_ident(context_arg, db_arg,table_name_arg,field_name_arg),
   field(0), result_field(0), item_equal(0), no_const_subst(0),
1798
   have_privileges(0), any_privileges(0)
1799
{
evgen@moonbone.local's avatar
evgen@moonbone.local committed
1800
  SELECT_LEX *select= current_thd->lex->current_select;
1801
  collation.set(DERIVATION_IMPLICIT);
evgen@moonbone.local's avatar
evgen@moonbone.local committed
1802 1803
  if (select && select->parsing_place != IN_HAVING)
      select->select_n_where_fields++;
1804 1805
}

1806 1807 1808 1809
/**
  Constructor need to process subselect with temporary tables (see Item)
*/

1810
Item_field::Item_field(THD *thd, Item_field *item)
1811
  :Item_ident(thd, item),
1812
   field(item->field),
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1813
   result_field(item->result_field),
1814 1815
   item_equal(item->item_equal),
   no_const_subst(item->no_const_subst),
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1816
   have_privileges(item->have_privileges),
1817
   any_privileges(item->any_privileges)
1818 1819 1820
{
  collation.set(DERIVATION_IMPLICIT);
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1821 1822 1823 1824 1825 1826

void Item_field::set_field(Field *field_par)
{
  field=result_field=field_par;			// for easy coding with fields
  maybe_null=field->maybe_null();
  decimals= field->decimals();
1827
  max_length= field_par->max_display_length();
1828 1829
  table_name= *field_par->table_name;
  field_name= field_par->field_name;
1830
  db_name= field_par->table->s->db.str;
1831
  alias_name_used= field_par->table->alias_name_used;
1832
  unsigned_flag=test(field_par->flags & UNSIGNED_FLAG);
1833
  collation.set(field_par->charset(), field_par->derivation());
1834
  fixed= 1;
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
1835 1836
  if (field->table->s->tmp_table == SYSTEM_TMP_TABLE)
    any_privileges= 0;
1837 1838 1839
}


1840
/**
1841 1842 1843 1844 1845 1846 1847 1848 1849 1850
  Reset this item to point to a field from the new temporary table.
  This is used when we create a new temporary table for each execution
  of prepared statement.
*/

void Item_field::reset_field(Field *f)
{
  set_field(f);
  /* 'name' is pointing at field->field_name of old field */
  name= (char*) f->field_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1851 1852 1853 1854 1855
}

const char *Item_ident::full_name() const
{
  char *tmp;
1856
  if (!table_name || !field_name)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1857
    return field_name ? field_name : name ? name : "tmp_field";
1858
  if (db_name && db_name[0])
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1859
  {
1860 1861
    tmp=(char*) sql_alloc((uint) strlen(db_name)+(uint) strlen(table_name)+
			  (uint) strlen(field_name)+3);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1862 1863 1864 1865
    strxmov(tmp,db_name,".",table_name,".",field_name,NullS);
  }
  else
  {
1866 1867 1868 1869 1870 1871 1872 1873
    if (table_name[0])
    {
      tmp= (char*) sql_alloc((uint) strlen(table_name) +
			     (uint) strlen(field_name) + 2);
      strxmov(tmp, table_name, ".", field_name, NullS);
    }
    else
      tmp= (char*) field_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1874 1875 1876 1877
  }
  return tmp;
}

1878
void Item_ident::print(String *str, enum_query_type query_type)
1879
{
1880
  THD *thd= current_thd;
1881 1882
  char d_name_buff[MAX_ALIAS_NAME], t_name_buff[MAX_ALIAS_NAME];
  const char *d_name= db_name, *t_name= table_name;
1883 1884
  if (lower_case_table_names== 1 ||
      (lower_case_table_names == 2 && !alias_name_used))
1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899
  {
    if (table_name && table_name[0])
    {
      strmov(t_name_buff, table_name);
      my_casedn_str(files_charset_info, t_name_buff);
      t_name= t_name_buff;
    }
    if (db_name && db_name[0])
    {
      strmov(d_name_buff, db_name);
      my_casedn_str(files_charset_info, d_name_buff);
      d_name= d_name_buff;
    }
  }

1900
  if (!table_name || !field_name || !field_name[0])
1901
  {
1902 1903
    const char *nm= (field_name && field_name[0]) ?
                      field_name : name ? name : "tmp_field";
1904
    append_identifier(thd, str, nm, (uint) strlen(nm));
1905 1906
    return;
  }
1907
  if (db_name && db_name[0] && !alias_name_used)
1908
  {
1909 1910 1911
    if (!(cached_table && cached_table->belong_to_view &&
          cached_table->belong_to_view->compact_view_format))
    {
1912
      append_identifier(thd, str, d_name, (uint)strlen(d_name));
1913 1914
      str->append('.');
    }
1915
    append_identifier(thd, str, t_name, (uint)strlen(t_name));
1916
    str->append('.');
1917
    append_identifier(thd, str, field_name, (uint)strlen(field_name));
1918 1919 1920 1921 1922
  }
  else
  {
    if (table_name[0])
    {
1923
      append_identifier(thd, str, t_name, (uint) strlen(t_name));
1924
      str->append('.');
1925
      append_identifier(thd, str, field_name, (uint) strlen(field_name));
1926 1927
    }
    else
1928
      append_identifier(thd, str, field_name, (uint) strlen(field_name));
1929 1930 1931
  }
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1932 1933 1934
/* ARGSUSED */
String *Item_field::val_str(String *str)
{
1935
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1936 1937
  if ((null_value=field->is_null()))
    return 0;
1938
  str->set_charset(str_value.charset());
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1939 1940 1941
  return field->val_str(str,&str_value);
}

1942

1943
double Item_field::val_real()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1944
{
1945
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1946 1947 1948 1949 1950
  if ((null_value=field->is_null()))
    return 0.0;
  return field->val_real();
}

1951

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1952 1953
longlong Item_field::val_int()
{
1954
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1955 1956 1957 1958 1959 1960
  if ((null_value=field->is_null()))
    return 0;
  return field->val_int();
}


1961 1962 1963 1964 1965 1966 1967 1968
my_decimal *Item_field::val_decimal(my_decimal *decimal_value)
{
  if ((null_value= field->is_null()))
    return 0;
  return field->val_decimal(decimal_value);
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
1969 1970 1971 1972
String *Item_field::str_result(String *str)
{
  if ((null_value=result_field->is_null()))
    return 0;
1973
  str->set_charset(str_value.charset());
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1974 1975 1976
  return result_field->val_str(str,&str_value);
}

1977
bool Item_field::get_date(MYSQL_TIME *ltime,uint fuzzydate)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1978 1979 1980 1981 1982 1983 1984 1985 1986
{
  if ((null_value=field->is_null()) || field->get_date(ltime,fuzzydate))
  {
    bzero((char*) ltime,sizeof(*ltime));
    return 1;
  }
  return 0;
}

1987
bool Item_field::get_date_result(MYSQL_TIME *ltime,uint fuzzydate)
1988 1989 1990 1991 1992 1993 1994 1995 1996 1997
{
  if ((null_value=result_field->is_null()) ||
      result_field->get_date(ltime,fuzzydate))
  {
    bzero((char*) ltime,sizeof(*ltime));
    return 1;
  }
  return 0;
}

1998
bool Item_field::get_time(MYSQL_TIME *ltime)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021
{
  if ((null_value=field->is_null()) || field->get_time(ltime))
  {
    bzero((char*) ltime,sizeof(*ltime));
    return 1;
  }
  return 0;
}

double Item_field::val_result()
{
  if ((null_value=result_field->is_null()))
    return 0.0;
  return result_field->val_real();
}

longlong Item_field::val_int_result()
{
  if ((null_value=result_field->is_null()))
    return 0;
  return result_field->val_int();
}

2022

2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034
my_decimal *Item_field::val_decimal_result(my_decimal *decimal_value)
{
  if ((null_value= result_field->is_null()))
    return 0;
  return result_field->val_decimal(decimal_value);
}


bool Item_field::val_bool_result()
{
  if ((null_value= result_field->is_null()))
    return FALSE;
2035
  switch (result_field->result_type()) {
2036
  case INT_RESULT:
2037
    return result_field->val_int() != 0;
2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051
  case DECIMAL_RESULT:
  {
    my_decimal decimal_value;
    my_decimal *val= result_field->val_decimal(&decimal_value);
    if (val)
      return !my_decimal_is_zero(val);
    return 0;
  }
  case REAL_RESULT:
  case STRING_RESULT:
    return result_field->val_real() != 0.0;
  case ROW_RESULT:
  default:
    DBUG_ASSERT(0);
2052
    return 0;                                   // Shut up compiler
2053 2054 2055 2056
  }
}


2057
bool Item_field::eq(const Item *item, bool binary_cmp) const
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2058
{
2059 2060
  Item *real_item= ((Item *) item)->real_item();
  if (real_item->type() != FIELD_ITEM)
2061 2062
    return 0;
  
2063
  Item_field *item_field= (Item_field*) real_item;
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2064
  if (item_field->field && field)
2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077
    return item_field->field == field;
  /*
    We may come here when we are trying to find a function in a GROUP BY
    clause from the select list.
    In this case the '100 % correct' way to do this would be to first
    run fix_fields() on the GROUP BY item and then retry this function, but
    I think it's better to relax the checking a bit as we will in
    most cases do the correct thing by just checking the field name.
    (In cases where we would choose wrong we would have to generate a
    ER_NON_UNIQ_ERROR).
  */
  return (!my_strcasecmp(system_charset_info, item_field->name,
			 field_name) &&
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2078
	  (!item_field->table_name || !table_name ||
2079 2080
	   (!my_strcasecmp(table_alias_charset, item_field->table_name,
			   table_name) &&
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2081
	    (!item_field->db_name || !db_name ||
2082 2083
	     (item_field->db_name && !strcmp(item_field->db_name,
					     db_name))))));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2084 2085
}

2086

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2087 2088 2089 2090
table_map Item_field::used_tables() const
{
  if (field->table->const_table)
    return 0;					// const item
2091
  return (depended_from ? OUTER_REF_TABLE_BIT : field->table->map);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2092 2093
}

2094

2095
Item *Item_field::get_tmp_table_item(THD *thd)
2096
{
2097
  Item_field *new_item= new Item_field(thd, this);
2098 2099 2100 2101
  if (new_item)
    new_item->field= new_item->result_field;
  return new_item;
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2102

2103 2104 2105 2106 2107
longlong Item_field::val_int_endpoint(bool left_endp, bool *incl_endp)
{
  longlong res= val_int();
  return null_value? LONGLONG_MIN : res;
}
2108

2109
/**
2110
  Create an item from a string we KNOW points to a valid longlong
2111
  end \\0 terminated number string.
2112
  This is always 'signed'. Unsigned values are created with Item_uint()
monty@mysql.com's avatar
monty@mysql.com committed
2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125
*/

Item_int::Item_int(const char *str_arg, uint length)
{
  char *end_ptr= (char*) str_arg + length;
  int error;
  value= my_strtoll10(str_arg, &end_ptr, &error);
  max_length= (uint) (end_ptr - str_arg);
  name= (char*) str_arg;
  fixed= 1;
}


2126 2127 2128 2129 2130 2131
my_decimal *Item_int::val_decimal(my_decimal *decimal_value)
{
  int2my_decimal(E_DEC_FATAL_ERROR, value, unsigned_flag, decimal_value);
  return decimal_value;
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2132 2133
String *Item_int::val_str(String *str)
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2134
  // following assert is redundant, because fixed=1 assigned in constructor
2135
  DBUG_ASSERT(fixed == 1);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2136
  str->set(value, &my_charset_bin);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2137 2138 2139
  return str;
}

2140
void Item_int::print(String *str, enum_query_type query_type)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2141
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2142 2143
  // my_charset_bin is good enough for numbers
  str_value.set(value, &my_charset_bin);
2144
  str->append(str_value);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2145 2146
}

2147

monty@mysql.com's avatar
monty@mysql.com committed
2148 2149 2150 2151 2152 2153 2154
Item_uint::Item_uint(const char *str_arg, uint length):
  Item_int(str_arg, length)
{
  unsigned_flag= 1;
}


2155 2156 2157 2158 2159 2160 2161
Item_uint::Item_uint(const char *str_arg, longlong i, uint length):
  Item_int(str_arg, i, length)
{
  unsigned_flag= 1;
}


2162 2163
String *Item_uint::val_str(String *str)
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2164
  // following assert is redundant, because fixed=1 assigned in constructor
2165
  DBUG_ASSERT(fixed == 1);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2166
  str->set((ulonglong) value, &my_charset_bin);
2167 2168 2169
  return str;
}

2170

2171
void Item_uint::print(String *str, enum_query_type query_type)
2172
{
2173
  // latin1 is good enough for numbers
2174 2175
  str_value.set((ulonglong) value, default_charset());
  str->append(str_value);
2176 2177
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2178

2179 2180 2181 2182 2183 2184 2185
Item_decimal::Item_decimal(const char *str_arg, uint length,
                           CHARSET_INFO *charset)
{
  str2my_decimal(E_DEC_FATAL_ERROR, str_arg, length, charset, &decimal_value);
  name= (char*) str_arg;
  decimals= (uint8) decimal_value.frac;
  fixed= 1;
2186 2187
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
                                             decimals, unsigned_flag);
2188 2189 2190 2191 2192 2193 2194
}

Item_decimal::Item_decimal(longlong val, bool unsig)
{
  int2my_decimal(E_DEC_FATAL_ERROR, val, unsig, &decimal_value);
  decimals= (uint8) decimal_value.frac;
  fixed= 1;
2195 2196
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
                                             decimals, unsigned_flag);
2197 2198 2199 2200 2201 2202 2203 2204
}


Item_decimal::Item_decimal(double val, int precision, int scale)
{
  double2my_decimal(E_DEC_FATAL_ERROR, val, &decimal_value);
  decimals= (uint8) decimal_value.frac;
  fixed= 1;
2205 2206
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
                                             decimals, unsigned_flag);
2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225
}


Item_decimal::Item_decimal(const char *str, const my_decimal *val_arg,
                           uint decimal_par, uint length)
{
  my_decimal2decimal(val_arg, &decimal_value);
  name= (char*) str;
  decimals= (uint8) decimal_par;
  max_length= length;
  fixed= 1;
}


Item_decimal::Item_decimal(my_decimal *value_par)
{
  my_decimal2decimal(value_par, &decimal_value);
  decimals= (uint8) decimal_value.frac;
  fixed= 1;
2226
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
2227
                                             decimals, unsigned_flag);
2228 2229 2230
}


2231
Item_decimal::Item_decimal(const uchar *bin, int precision, int scale)
2232
{
2233 2234
  binary2my_decimal(E_DEC_FATAL_ERROR, bin,
                    &decimal_value, precision, scale);
2235 2236
  decimals= (uint8) decimal_value.frac;
  fixed= 1;
2237
  max_length= my_decimal_precision_to_length(precision, decimals,
2238
                                             unsigned_flag);
2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262
}


longlong Item_decimal::val_int()
{
  longlong result;
  my_decimal2int(E_DEC_FATAL_ERROR, &decimal_value, unsigned_flag, &result);
  return result;
}

double Item_decimal::val_real()
{
  double result;
  my_decimal2double(E_DEC_FATAL_ERROR, &decimal_value, &result);
  return result;
}

String *Item_decimal::val_str(String *result)
{
  result->set_charset(&my_charset_bin);
  my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value, 0, 0, 0, result);
  return result;
}

2263
void Item_decimal::print(String *str, enum_query_type query_type)
2264 2265 2266 2267 2268 2269
{
  my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value, 0, 0, 0, &str_value);
  str->append(str_value);
}


2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287
bool Item_decimal::eq(const Item *item, bool binary_cmp) const
{
  if (type() == item->type() && item->basic_const_item())
  {
    /*
      We need to cast off const to call val_decimal(). This should
      be OK for a basic constant. Additionally, we can pass 0 as
      a true decimal constant will return its internal decimal
      storage and ignore the argument.
    */
    Item *arg= (Item*) item;
    my_decimal *value= arg->val_decimal(0);
    return !my_decimal_cmp(&decimal_value, value);
  }
  return 0;
}


2288 2289 2290 2291 2292 2293 2294 2295 2296 2297
void Item_decimal::set_decimal_value(my_decimal *value_par)
{
  my_decimal2decimal(value_par, &decimal_value);
  decimals= (uint8) decimal_value.frac;
  unsigned_flag= !decimal_value.sign();
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
                                             decimals, unsigned_flag);
}


2298
String *Item_float::val_str(String *str)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2299
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2300
  // following assert is redundant, because fixed=1 assigned in constructor
2301
  DBUG_ASSERT(fixed == 1);
2302
  str->set_real(value,decimals,&my_charset_bin);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2303 2304 2305
  return str;
}

2306

2307 2308 2309 2310 2311 2312 2313 2314 2315
my_decimal *Item_float::val_decimal(my_decimal *decimal_value)
{
  // following assert is redundant, because fixed=1 assigned in constructor
  DBUG_ASSERT(fixed == 1);
  double2my_decimal(E_DEC_FATAL_ERROR, value, decimal_value);
  return (decimal_value);
}


2316
void Item_string::print(String *str, enum_query_type query_type)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2317
{
2318
  if (query_type == QT_ORDINARY && is_cs_specified())
2319 2320 2321 2322 2323
  {
    str->append('_');
    str->append(collation.collation->csname);
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2324
  str->append('\'');
2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348

  if (query_type == QT_ORDINARY ||
      my_charset_same(str_value.charset(), system_charset_info))
  {
    str_value.print(str);
  }
  else
  {
    THD *thd= current_thd;
    LEX_STRING utf8_lex_str;

    thd->convert_string(&utf8_lex_str,
                        system_charset_info,
                        str_value.c_ptr_safe(),
                        str_value.length(),
                        str_value.charset());

    String utf8_str(utf8_lex_str.str,
                    utf8_lex_str.length,
                    system_charset_info);

    utf8_str.print(str);
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2349 2350 2351
  str->append('\'');
}

2352

2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365
double Item_string::val_real()
{
  DBUG_ASSERT(fixed == 1);
  int error;
  char *end, *org_end;
  double tmp;
  CHARSET_INFO *cs= str_value.charset();

  org_end= (char*) str_value.ptr() + str_value.length();
  tmp= my_strntod(cs, (char*) str_value.ptr(), str_value.length(), &end,
                  &error);
  if (error || (end != org_end && !check_if_only_end_space(cs, end, org_end)))
  {
2366 2367 2368 2369
    /*
      We can use str_value.ptr() here as Item_string is gurantee to put an
      end \0 here.
    */
2370 2371 2372 2373 2374 2375 2376 2377 2378
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_TRUNCATED_WRONG_VALUE,
                        ER(ER_TRUNCATED_WRONG_VALUE), "DOUBLE",
                        str_value.ptr());
  }
  return tmp;
}


2379 2380 2381 2382
/**
  @todo
  Give error if we wanted a signed integer and we got an unsigned one
*/
2383 2384 2385 2386 2387 2388 2389 2390 2391
longlong Item_string::val_int()
{
  DBUG_ASSERT(fixed == 1);
  int err;
  longlong tmp;
  char *end= (char*) str_value.ptr()+ str_value.length();
  char *org_end= end;
  CHARSET_INFO *cs= str_value.charset();

serg@serg.mylan's avatar
serg@serg.mylan committed
2392
  tmp= (*(cs->cset->strtoll10))(cs, str_value.ptr(), &end, &err);
2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408
  /*
    TODO: Give error if we wanted a signed integer and we got an unsigned
    one
  */
  if (err > 0 ||
      (end != org_end && !check_if_only_end_space(cs, end, org_end)))
  {
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                        ER_TRUNCATED_WRONG_VALUE,
                        ER(ER_TRUNCATED_WRONG_VALUE), "INTEGER",
                        str_value.ptr());
  }
  return tmp;
}


2409 2410
my_decimal *Item_string::val_decimal(my_decimal *decimal_value)
{
2411
  return val_decimal_from_string(decimal_value);
2412 2413 2414
}


2415 2416
bool Item_null::eq(const Item *item, bool binary_cmp) const
{ return item->type() == type(); }
2417 2418


2419
double Item_null::val_real()
2420
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2421 2422
  // following assert is redundant, because fixed=1 assigned in constructor
  DBUG_ASSERT(fixed == 1);
2423 2424 2425 2426 2427
  null_value=1;
  return 0.0;
}
longlong Item_null::val_int()
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2428 2429
  // following assert is redundant, because fixed=1 assigned in constructor
  DBUG_ASSERT(fixed == 1);
2430 2431 2432
  null_value=1;
  return 0;
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2433 2434
/* ARGSUSED */
String *Item_null::val_str(String *str)
2435
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2436 2437
  // following assert is redundant, because fixed=1 assigned in constructor
  DBUG_ASSERT(fixed == 1);
2438 2439 2440
  null_value=1;
  return 0;
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2441

2442 2443 2444 2445 2446
my_decimal *Item_null::val_decimal(my_decimal *decimal_value)
{
  return 0;
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2447

2448 2449 2450 2451 2452 2453
Item *Item_null::safe_charset_converter(CHARSET_INFO *tocs)
{
  collation.set(tocs);
  return this;
}

2454 2455
/*********************** Item_param related ******************************/

2456
/** 
2457
  Default function of Item_param::set_param_func, so in case
2458
  of malformed packet the server won't SIGSEGV.
2459 2460 2461 2462 2463 2464 2465 2466 2467 2468
*/

static void
default_set_param_func(Item_param *param,
                       uchar **pos __attribute__((unused)),
                       ulong len __attribute__((unused)))
{
  param->set_null();
}

2469

2470
Item_param::Item_param(uint pos_in_query_arg) :
2471
  state(NO_VALUE),
2472
  item_result_type(STRING_RESULT),
2473 2474
  /* Don't pretend to be a literal unless value for this item is set. */
  item_type(PARAM_ITEM),
2475
  param_type(MYSQL_TYPE_VARCHAR),
2476
  pos_in_query(pos_in_query_arg),
2477 2478
  set_param_func(default_set_param_func),
  limit_clause_param(FALSE)
2479 2480
{
  name= (char*) "?";
2481 2482 2483 2484 2485 2486
  /* 
    Since we can't say whenever this item can be NULL or cannot be NULL
    before mysql_stmt_execute(), so we assuming that it can be NULL until
    value is set.
  */
  maybe_null= 1;
bar@mysql.com's avatar
bar@mysql.com committed
2487 2488
  cnvitem= new Item_string("", 0, &my_charset_bin, DERIVATION_COERCIBLE);
  cnvstr.set(cnvbuf, sizeof(cnvbuf), &my_charset_bin);
2489
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2490

2491

2492
void Item_param::set_null()
2493 2494
{
  DBUG_ENTER("Item_param::set_null");
2495
  /* These are cleared after each execution by reset() method */
2496 2497 2498 2499 2500 2501 2502 2503 2504
  null_value= 1;
  /* 
    Because of NULL and string values we need to set max_length for each new
    placeholder value: user can submit NULL for any placeholder type, and 
    string length can be different in each execution.
  */
  max_length= 0;
  decimals= 0;
  state= NULL_VALUE;
2505
  item_type= Item::NULL_ITEM;
2506
  DBUG_VOID_RETURN;
2507 2508
}

2509
void Item_param::set_int(longlong i, uint32 max_length_arg)
2510 2511
{
  DBUG_ENTER("Item_param::set_int");
2512 2513 2514 2515
  value.integer= (longlong) i;
  state= INT_VALUE;
  max_length= max_length_arg;
  decimals= 0;
2516
  maybe_null= 0;
2517
  DBUG_VOID_RETURN;
2518 2519
}

2520
void Item_param::set_double(double d)
2521 2522
{
  DBUG_ENTER("Item_param::set_double");
2523 2524 2525
  value.real= d;
  state= REAL_VALUE;
  max_length= DBL_DIG + 8;
2526
  decimals= NOT_FIXED_DEC;
2527
  maybe_null= 0;
2528
  DBUG_VOID_RETURN;
2529 2530 2531
}


2532
/**
2533 2534
  Set decimal parameter value from string.

2535 2536
  @param str      character string
  @param length   string length
2537

2538 2539
  @note
    As we use character strings to send decimal values in
2540 2541 2542
    binary protocol, we use str2my_decimal to convert it to
    internal decimal value.
*/
2543

2544 2545
void Item_param::set_decimal(const char *str, ulong length)
{
2546
  char *end;
2547 2548
  DBUG_ENTER("Item_param::set_decimal");

2549 2550
  end= (char*) str+length;
  str2my_decimal(E_DEC_FATAL_ERROR, str, &decimal_value, &end);
2551 2552
  state= DECIMAL_VALUE;
  decimals= decimal_value.frac;
2553 2554
  max_length= my_decimal_precision_to_length(decimal_value.precision(),
                                             decimals, unsigned_flag);
2555 2556 2557 2558 2559
  maybe_null= 0;
  DBUG_VOID_RETURN;
}


2560
/**
2561
  Set parameter value from MYSQL_TIME value.
2562

2563 2564 2565
  @param tm              datetime value to set (time_type is ignored)
  @param type            type of datetime value
  @param max_length_arg  max length of datetime value as string
2566

2567
  @note
2568 2569 2570 2571 2572
    If we value to be stored is not normalized, zero value will be stored
    instead and proper warning will be produced. This function relies on
    the fact that even wrong value sent over binary protocol fits into
    MAX_DATE_STRING_REP_LENGTH buffer.
*/
2573
void Item_param::set_time(MYSQL_TIME *tm, timestamp_type time_type,
2574
                          uint32 max_length_arg)
2575
{ 
2576
  DBUG_ENTER("Item_param::set_time");
2577

2578
  value.time= *tm;
2579
  value.time.time_type= time_type;
2580

2581 2582
  if (value.time.year > 9999 || value.time.month > 12 ||
      value.time.day > 31 ||
2583
      time_type != MYSQL_TIMESTAMP_TIME && value.time.hour > 23 ||
2584 2585 2586 2587
      value.time.minute > 59 || value.time.second > 59)
  {
    char buff[MAX_DATE_STRING_REP_LENGTH];
    uint length= my_TIME_to_str(&value.time, buff);
2588 2589
    make_truncated_value_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                                 buff, length, time_type, 0);
2590 2591 2592
    set_zero_time(&value.time, MYSQL_TIMESTAMP_ERROR);
  }

2593
  state= TIME_VALUE;
2594
  maybe_null= 0;
2595 2596
  max_length= max_length_arg;
  decimals= 0;
2597
  DBUG_VOID_RETURN;
2598 2599
}

2600

2601 2602 2603 2604 2605 2606 2607
bool Item_param::set_str(const char *str, ulong length)
{
  DBUG_ENTER("Item_param::set_str");
  /*
    Assign string with no conversion: data is converted only after it's
    been written to the binary log.
  */
2608 2609 2610
  uint dummy_errors;
  if (str_value.copy(str, length, &my_charset_bin, &my_charset_bin,
                     &dummy_errors))
2611 2612
    DBUG_RETURN(TRUE);
  state= STRING_VALUE;
2613
  max_length= length;
2614
  maybe_null= 0;
2615 2616 2617
  /* max_length and decimals are set after charset conversion */
  /* sic: str may be not null-terminated, don't add DBUG_PRINT here */
  DBUG_RETURN(FALSE);
2618 2619 2620
}


2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636
bool Item_param::set_longdata(const char *str, ulong length)
{
  DBUG_ENTER("Item_param::set_longdata");

  /*
    If client character set is multibyte, end of long data packet
    may hit at the middle of a multibyte character.  Additionally,
    if binary log is open we must write long data value to the
    binary log in character set of client. This is why we can't
    convert long data to connection character set as it comes
    (here), and first have to concatenate all pieces together,
    write query to the binary log and only then perform conversion.
  */
  if (str_value.append(str, length, &my_charset_bin))
    DBUG_RETURN(TRUE);
  state= LONG_DATA_VALUE;
2637
  maybe_null= 0;
2638 2639

  DBUG_RETURN(FALSE);
2640 2641 2642
}


2643
/**
2644 2645
  Set parameter value from user variable value.

2646 2647
  @param thd   Current thread
  @param entry User variable structure (NULL means use NULL value)
2648

2649
  @retval
2650
    0 OK
2651
  @retval
2652
    1 Out of memory
2653 2654 2655 2656 2657 2658 2659 2660
*/

bool Item_param::set_from_user_var(THD *thd, const user_var_entry *entry)
{
  DBUG_ENTER("Item_param::set_from_user_var");
  if (entry && entry->value)
  {
    item_result_type= entry->type;
2661
    unsigned_flag= entry->unsigned_flag;
2662 2663 2664 2665 2666 2667 2668
    if (limit_clause_param)
    {
      my_bool unused;
      set_int(entry->val_int(&unused), MY_INT64_NUM_DECIMAL_DIGITS);
      item_type= Item::INT_ITEM;
      DBUG_RETURN(!unsigned_flag && value.integer < 0 ? 1 : 0);
    }
2669
    switch (item_result_type) {
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2670 2671
    case REAL_RESULT:
      set_double(*(double*)entry->value);
2672
      item_type= Item::REAL_ITEM;
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2673 2674
      break;
    case INT_RESULT:
2675
      set_int(*(longlong*)entry->value, MY_INT64_NUM_DECIMAL_DIGITS);
2676
      item_type= Item::INT_ITEM;
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2677 2678
      break;
    case STRING_RESULT:
2679
    {
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2680 2681 2682 2683
      CHARSET_INFO *fromcs= entry->collation.collation;
      CHARSET_INFO *tocs= thd->variables.collation_connection;
      uint32 dummy_offset;

2684 2685
      value.cs_info.character_set_of_placeholder= 
        value.cs_info.character_set_client= fromcs;
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703
      /*
        Setup source and destination character sets so that they
        are different only if conversion is necessary: this will
        make later checks easier.
      */
      value.cs_info.final_character_set_of_str_value=
        String::needs_conversion(0, fromcs, tocs, &dummy_offset) ?
        tocs : fromcs;
      /*
        Exact value of max_length is not known unless data is converted to
        charset of connection, so we have to set it later.
      */
      item_type= Item::STRING_ITEM;

      if (set_str((const char *)entry->value, entry->length))
        DBUG_RETURN(1);
      break;
    }
2704 2705 2706 2707 2708 2709
    case DECIMAL_RESULT:
    {
      const my_decimal *ent_value= (const my_decimal *)entry->value;
      my_decimal2decimal(ent_value, &decimal_value);
      state= DECIMAL_VALUE;
      decimals= ent_value->frac;
2710 2711
      max_length= my_decimal_precision_to_length(ent_value->precision(),
                                                 decimals, unsigned_flag);
2712
      item_type= Item::DECIMAL_ITEM;
2713 2714
      break;
    }
sergefp@mysql.com's avatar
sergefp@mysql.com committed
2715 2716 2717
    default:
      DBUG_ASSERT(0);
      set_null();
2718 2719 2720 2721 2722 2723 2724 2725
    }
  }
  else
    set_null();

  DBUG_RETURN(0);
}

2726 2727 2728 2729 2730
/**
  Resets parameter after execution.

  @note
    We clear null_value here instead of setting it in set_* methods,
2731 2732 2733 2734
    because we want more easily handle case for long data.
*/

void Item_param::reset()
2735
{
2736
  DBUG_ENTER("Item_param::reset");
2737 2738 2739 2740 2741
  /* Shrink string buffer if it's bigger than max possible CHAR column */
  if (str_value.alloced_length() > MAX_CHAR_WIDTH)
    str_value.free();
  else
    str_value.length(0);
2742
  str_value_ptr.length(0);
2743
  /*
2744
    We must prevent all charset conversions until data has been written
2745
    to the binary log.
2746 2747
  */
  str_value.set_charset(&my_charset_bin);
2748
  collation.set(&my_charset_bin, DERIVATION_COERCIBLE);
2749
  state= NO_VALUE;
2750 2751
  maybe_null= 1;
  null_value= 0;
2752 2753 2754 2755 2756 2757 2758 2759 2760
  /*
    Don't reset item_type to PARAM_ITEM: it's only needed to guard
    us from item optimizations at prepare stage, when item doesn't yet
    contain a literal of some kind.
    In all other cases when this object is accessed its value is
    set (this assumption is guarded by 'state' and
    DBUG_ASSERTS(state != NO_VALUE) in all Item_param::get_*
    methods).
  */
2761
  DBUG_VOID_RETURN;
2762 2763 2764
}


venu@myvenu.com's avatar
venu@myvenu.com committed
2765
int Item_param::save_in_field(Field *field, bool no_conversions)
2766 2767
{
  field->set_notnull();
2768 2769 2770

  switch (state) {
  case INT_VALUE:
2771
    return field->store(value.integer, unsigned_flag);
2772 2773
  case REAL_VALUE:
    return field->store(value.real);
2774 2775
  case DECIMAL_VALUE:
    return field->store_decimal(&decimal_value);
2776 2777
  case TIME_VALUE:
    field->store_time(&value.time, value.time.time_type);
2778
    return 0;
2779 2780 2781 2782 2783
  case STRING_VALUE:
  case LONG_DATA_VALUE:
    return field->store(str_value.ptr(), str_value.length(),
                        str_value.charset());
  case NULL_VALUE:
2784
    return set_field_to_null_with_conversions(field, no_conversions);
2785 2786 2787
  case NO_VALUE:
  default:
    DBUG_ASSERT(0);
2788
  }
2789
  return 1;
2790 2791
}

2792

2793
bool Item_param::get_time(MYSQL_TIME *res)
2794
{
2795 2796 2797 2798 2799 2800 2801 2802 2803 2804
  if (state == TIME_VALUE)
  {
    *res= value.time;
    return 0;
  }
  /*
    If parameter value isn't supplied assertion will fire in val_str()
    which is called from Item::get_time().
  */
  return Item::get_time(res);
2805
}
2806

2807

2808
bool Item_param::get_date(MYSQL_TIME *res, uint fuzzydate)
2809 2810 2811 2812 2813 2814 2815 2816 2817 2818
{
  if (state == TIME_VALUE)
  {
    *res= value.time;
    return 0;
  }
  return Item::get_date(res, fuzzydate);
}


2819
double Item_param::val_real()
2820
{
2821 2822 2823 2824 2825
  switch (state) {
  case REAL_VALUE:
    return value.real;
  case INT_VALUE:
    return (double) value.integer;
2826 2827 2828 2829 2830 2831
  case DECIMAL_VALUE:
  {
    double result;
    my_decimal2double(E_DEC_FATAL_ERROR, &decimal_value, &result);
    return result;
  }
2832 2833
  case STRING_VALUE:
  case LONG_DATA_VALUE:
2834 2835 2836 2837 2838 2839
  {
    int dummy_err;
    char *end_not_used;
    return my_strntod(str_value.charset(), (char*) str_value.ptr(),
                      str_value.length(), &end_not_used, &dummy_err);
  }
2840 2841 2842 2843 2844
  case TIME_VALUE:
    /*
      This works for example when user says SELECT ?+0.0 and supplies
      time value for the placeholder.
    */
2845
    return ulonglong2double(TIME_to_ulonglong(&value.time));
2846
  case NULL_VALUE:
2847
    return 0.0;
2848
  default:
2849
    DBUG_ASSERT(0);
2850
  }
2851
  return 0.0;
2852 2853
} 

2854

2855 2856
longlong Item_param::val_int() 
{ 
2857 2858
  switch (state) {
  case REAL_VALUE:
2859
    return (longlong) rint(value.real);
2860 2861
  case INT_VALUE:
    return value.integer;
2862 2863 2864 2865 2866 2867
  case DECIMAL_VALUE:
  {
    longlong i;
    my_decimal2int(E_DEC_FATAL_ERROR, &decimal_value, unsigned_flag, &i);
    return i;
  }
2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878
  case STRING_VALUE:
  case LONG_DATA_VALUE:
    {
      int dummy_err;
      return my_strntoll(str_value.charset(), str_value.ptr(),
                         str_value.length(), 10, (char**) 0, &dummy_err);
    }
  case TIME_VALUE:
    return (longlong) TIME_to_ulonglong(&value.time);
  case NULL_VALUE:
    return 0; 
2879
  default:
2880
    DBUG_ASSERT(0);
2881
  }
2882
  return 0;
2883 2884
}

2885

2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915
my_decimal *Item_param::val_decimal(my_decimal *dec)
{
  switch (state) {
  case DECIMAL_VALUE:
    return &decimal_value;
  case REAL_VALUE:
    double2my_decimal(E_DEC_FATAL_ERROR, value.real, dec);
    return dec;
  case INT_VALUE:
    int2my_decimal(E_DEC_FATAL_ERROR, value.integer, unsigned_flag, dec);
    return dec;
  case STRING_VALUE:
  case LONG_DATA_VALUE:
    string2my_decimal(E_DEC_FATAL_ERROR, &str_value, dec);
    return dec;
  case TIME_VALUE:
  {
    longlong i= (longlong) TIME_to_ulonglong(&value.time);
    int2my_decimal(E_DEC_FATAL_ERROR, i, 0, dec);
    return dec;
  }
  case NULL_VALUE:
    return 0; 
  default:
    DBUG_ASSERT(0);
  }
  return 0;
}


2916 2917
String *Item_param::val_str(String* str) 
{ 
2918 2919 2920
  switch (state) {
  case STRING_VALUE:
  case LONG_DATA_VALUE:
2921
    return &str_value_ptr;
2922
  case REAL_VALUE:
2923
    str->set_real(value.real, NOT_FIXED_DEC, &my_charset_bin);
2924 2925 2926
    return str;
  case INT_VALUE:
    str->set(value.integer, &my_charset_bin);
2927
    return str;
2928 2929 2930 2931 2932
  case DECIMAL_VALUE:
    if (my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value,
                          0, 0, 0, str) <= 1)
      return str;
    return NULL;
2933 2934
  case TIME_VALUE:
  {
2935
    if (str->reserve(MAX_DATE_STRING_REP_LENGTH))
2936
      break;
2937 2938
    str->length((uint) my_TIME_to_str(&value.time, (char*) str->ptr()));
    str->set_charset(&my_charset_bin);
2939
    return str;
2940 2941 2942
  }
  case NULL_VALUE:
    return NULL; 
2943
  default:
2944
    DBUG_ASSERT(0);
2945
  }
2946
  return str;
2947
}
2948

2949
/**
2950
  Return Param item values in string format, for generating the dynamic 
2951 2952 2953 2954 2955 2956 2957
  query used in update/binary logs.

  @todo
    - Change interface and implementation to fill log data in place
    and avoid one more memcpy/alloc between str and log string.
    - In case of error we need to notify replication
    that binary log contains wrong statement 
2958 2959
*/

2960
const String *Item_param::query_val_str(String* str) const
2961
{
2962 2963
  switch (state) {
  case INT_VALUE:
2964
    str->set_int(value.integer, unsigned_flag, &my_charset_bin);
2965 2966
    break;
  case REAL_VALUE:
2967
    str->set_real(value.real, NOT_FIXED_DEC, &my_charset_bin);
2968
    break;
2969 2970 2971 2972 2973
  case DECIMAL_VALUE:
    if (my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value,
                          0, 0, 0, str) > 1)
      return &my_null_string;
    break;
2974
  case TIME_VALUE:
2975
    {
2976 2977 2978 2979 2980 2981
      char *buf, *ptr;
      str->length(0);
      /*
        TODO: in case of error we need to notify replication
        that binary log contains wrong statement 
      */
2982
      if (str->reserve(MAX_DATE_STRING_REP_LENGTH+3))
2983 2984 2985 2986 2987 2988
        break; 

      /* Create date string inplace */
      buf= str->c_ptr_quick();
      ptr= buf;
      *ptr++= '\'';
2989
      ptr+= (uint) my_TIME_to_str(&value.time, ptr);
2990 2991 2992
      *ptr++= '\'';
      str->length((uint32) (ptr - buf));
      break;
2993
    }
2994 2995
  case STRING_VALUE:
  case LONG_DATA_VALUE:
2996
    {
2997
      str->length(0);
2998
      append_query_string(value.cs_info.character_set_client, &str_value, str);
2999
      break;
3000
    }
3001 3002 3003 3004
  case NULL_VALUE:
    return &my_null_string;
  default:
    DBUG_ASSERT(0);
3005 3006 3007
  }
  return str;
}
3008 3009


3010
/**
3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026
  Convert string from client character set to the character set of
  connection.
*/

bool Item_param::convert_str_value(THD *thd)
{
  bool rc= FALSE;
  if (state == STRING_VALUE || state == LONG_DATA_VALUE)
  {
    /*
      Check is so simple because all charsets were set up properly
      in setup_one_conversion_function, where typecode of
      placeholder was also taken into account: the variables are different
      here only if conversion is really necessary.
    */
    if (value.cs_info.final_character_set_of_str_value !=
3027
        value.cs_info.character_set_of_placeholder)
3028 3029
    {
      rc= thd->convert_string(&str_value,
3030
                              value.cs_info.character_set_of_placeholder,
3031 3032
                              value.cs_info.final_character_set_of_str_value);
    }
3033 3034 3035 3036
    else
      str_value.set_charset(value.cs_info.final_character_set_of_str_value);
    /* Here str_value is guaranteed to be in final_character_set_of_str_value */

3037 3038
    max_length= str_value.length();
    decimals= 0;
3039 3040 3041 3042 3043 3044
    /*
      str_value_ptr is returned from val_str(). It must be not alloced
      to prevent it's modification by val_str() invoker.
    */
    str_value_ptr.set(str_value.ptr(), str_value.length(),
                      str_value.charset());
3045 3046
    /* Synchronize item charset with value charset */
    collation.set(str_value.charset(), DERIVATION_COERCIBLE);
3047 3048 3049 3050
  }
  return rc;
}

3051

3052 3053 3054 3055 3056 3057 3058
bool Item_param::basic_const_item() const
{
  if (state == NO_VALUE || state == TIME_VALUE)
    return FALSE;
  return TRUE;
}

3059

3060
Item *
3061
Item_param::clone_item()
3062 3063 3064 3065 3066 3067
{
  /* see comments in the header file */
  switch (state) {
  case NULL_VALUE:
    return new Item_null(name);
  case INT_VALUE:
3068 3069 3070
    return (unsigned_flag ?
            new Item_uint(name, value.integer, max_length) :
            new Item_int(name, value.integer, max_length));
3071
  case REAL_VALUE:
3072
    return new Item_float(name, value.real, decimals, max_length);
3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105
  case STRING_VALUE:
  case LONG_DATA_VALUE:
    return new Item_string(name, str_value.c_ptr_quick(), str_value.length(),
                           str_value.charset());
  case TIME_VALUE:
    break;
  case NO_VALUE:
  default:
    DBUG_ASSERT(0);
  };
  return 0;
}


bool
Item_param::eq(const Item *arg, bool binary_cmp) const
{
  Item *item;
  if (!basic_const_item() || !arg->basic_const_item() || arg->type() != type())
    return FALSE;
  /*
    We need to cast off const to call val_int(). This should be OK for
    a basic constant.
  */
  item= (Item*) arg;

  switch (state) {
  case NULL_VALUE:
    return TRUE;
  case INT_VALUE:
    return value.integer == item->val_int() &&
           unsigned_flag == item->unsigned_flag;
  case REAL_VALUE:
3106
    return value.real == item->val_real();
3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117
  case STRING_VALUE:
  case LONG_DATA_VALUE:
    if (binary_cmp)
      return !stringcmp(&str_value, &item->str_value);
    return !sortcmp(&str_value, &item->str_value, collation.collation);
  default:
    break;
  }
  return FALSE;
}

3118 3119
/* End of Item_param related */

3120
void Item_param::print(String *str, enum_query_type query_type)
3121 3122 3123 3124 3125 3126 3127
{
  if (state == NO_VALUE)
  {
    str->append('?');
  }
  else
  {
3128
    char buffer[STRING_BUFFER_USUAL_SIZE];
3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139
    String tmp(buffer, sizeof(buffer), &my_charset_bin);
    const String *res;
    res= query_val_str(&tmp);
    str->append(*res);
  }
}


/****************************************************************************
  Item_copy_string
****************************************************************************/
3140

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151
void Item_copy_string::copy()
{
  String *res=item->val_str(&str_value);
  if (res && res != &str_value)
    str_value.copy(*res);
  null_value=item->null_value;
}

/* ARGSUSED */
String *Item_copy_string::val_str(String *str)
{
3152
  // Item_copy_string is used without fix_fields call
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3153 3154 3155 3156 3157
  if (null_value)
    return (String*) 0;
  return &str_value;
}

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

3159 3160 3161 3162 3163 3164 3165 3166 3167 3168
my_decimal *Item_copy_string::val_decimal(my_decimal *decimal_value)
{
  // Item_copy_string is used without fix_fields call
  if (null_value)
    return 0;
  string2my_decimal(E_DEC_FATAL_ERROR, &str_value, decimal_value);
  return (decimal_value);
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
3169
/*
3170
  Functions to convert item to field (for send_fields)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3171 3172 3173
*/

/* ARGSUSED */
3174
bool Item::fix_fields(THD *thd, Item **ref)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3175
{
3176 3177

  // We do not check fields which are fixed during construction
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3178
  DBUG_ASSERT(fixed == 0 || basic_const_item());
3179
  fixed= 1;
3180
  return FALSE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3181 3182
}

3183
double Item_ref_null_helper::val_real()
3184
{
3185
  DBUG_ASSERT(fixed == 1);
3186
  double tmp= (*ref)->val_result();
3187
  owner->was_null|= null_value= (*ref)->null_value;
3188 3189
  return tmp;
}
3190 3191


3192 3193
longlong Item_ref_null_helper::val_int()
{
3194
  DBUG_ASSERT(fixed == 1);
3195
  longlong tmp= (*ref)->val_int_result();
3196
  owner->was_null|= null_value= (*ref)->null_value;
3197 3198
  return tmp;
}
3199 3200


3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218
my_decimal *Item_ref_null_helper::val_decimal(my_decimal *decimal_value)
{
  DBUG_ASSERT(fixed == 1);
  my_decimal *val= (*ref)->val_decimal_result(decimal_value);
  owner->was_null|= null_value= (*ref)->null_value;
  return val;
}


bool Item_ref_null_helper::val_bool()
{
  DBUG_ASSERT(fixed == 1);
  bool val= (*ref)->val_bool_result();
  owner->was_null|= null_value= (*ref)->null_value;
  return val;
}


3219 3220
String* Item_ref_null_helper::val_str(String* s)
{
3221
  DBUG_ASSERT(fixed == 1);
3222
  String* tmp= (*ref)->str_result(s);
3223
  owner->was_null|= null_value= (*ref)->null_value;
3224 3225
  return tmp;
}
3226 3227


3228
bool Item_ref_null_helper::get_date(MYSQL_TIME *ltime, uint fuzzydate)
3229 3230 3231
{  
  return (owner->was_null|= null_value= (*ref)->get_date(ltime, fuzzydate));
}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3232

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3233

3234 3235 3236
/**
  Mark item and SELECT_LEXs as dependent if item was resolved in
  outer SELECT.
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3237

3238 3239 3240 3241 3242 3243
  @param thd             thread handler
  @param last            select from which current item depend
  @param current         current select
  @param resolved_item   item which was resolved in outer SELECT(for warning)
  @param mark_item       item which should be marked (can be differ in case of
                         substitution)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3244 3245
*/

3246
static void mark_as_dependent(THD *thd, SELECT_LEX *last, SELECT_LEX *current,
3247
                              Item_ident *resolved_item,
3248
                              Item_ident *mark_item)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3249
{
3250 3251 3252 3253
  const char *db_name= (resolved_item->db_name ?
                        resolved_item->db_name : "");
  const char *table_name= (resolved_item->table_name ?
                           resolved_item->table_name : "");
3254
  /* store pointer on SELECT_LEX from which item is dependent */
3255 3256
  if (mark_item)
    mark_item->depended_from= last;
3257
  current->mark_as_dependent(last);
pem@mysql.com's avatar
pem@mysql.com committed
3258
  if (thd->lex->describe & DESCRIBE_EXTENDED)
3259 3260 3261
  {
    char warn_buff[MYSQL_ERRMSG_SIZE];
    sprintf(warn_buff, ER(ER_WARN_FIELD_RESOLVED),
3262 3263
            db_name, (db_name[0] ? "." : ""),
            table_name, (table_name [0] ? "." : ""),
3264
            resolved_item->field_name,
3265 3266 3267 3268
	    current->select_number, last->select_number);
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		 ER_WARN_FIELD_RESOLVED, warn_buff);
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3269 3270 3271
}


3272 3273 3274
/**
  Mark range of selects and resolved identifier (field/reference)
  item as dependent.
3275

3276 3277 3278 3279 3280 3281 3282 3283 3284
  @param thd             thread handler
  @param last_select     select where resolved_item was resolved
  @param current_sel     current select (select where resolved_item was placed)
  @param found_field     field which was found during resolving
  @param found_item      Item which was found during resolving (if resolved
                         identifier belongs to VIEW)
  @param resolved_item   Identifier which was resolved

  @note
3285 3286 3287 3288 3289 3290 3291 3292 3293
    We have to mark all items between current_sel (including) and
    last_select (excluding) as dependend (select before last_select should
    be marked with actual table mask used by resolved item, all other with
    OUTER_REF_TABLE_BIT) and also write dependence information to Item of
    resolved identifier.
*/

void mark_select_range_as_dependent(THD *thd,
                                    SELECT_LEX *last_select,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3294
                                    SELECT_LEX *current_sel,
3295 3296 3297 3298 3299 3300 3301 3302 3303 3304
                                    Field *found_field, Item *found_item,
                                    Item_ident *resolved_item)
{
  /*
    Go from current SELECT to SELECT where field was resolved (it
    have to be reachable from current SELECT, because it was already
    done once when we resolved this field and cached result of
    resolving)
  */
  SELECT_LEX *previous_select= current_sel;
3305 3306
  for (; previous_select->outer_select() != last_select;
       previous_select= previous_select->outer_select())
3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333
  {
    Item_subselect *prev_subselect_item=
      previous_select->master_unit()->item;
    prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
    prev_subselect_item->const_item_cache= 0;
  }
  {
    Item_subselect *prev_subselect_item=
      previous_select->master_unit()->item;
    Item_ident *dependent= resolved_item;
    if (found_field == view_ref_found)
    {
      Item::Type type= found_item->type();
      prev_subselect_item->used_tables_cache|=
        found_item->used_tables();
      dependent= ((type == Item::REF_ITEM || type == Item::FIELD_ITEM) ?
                  (Item_ident*) found_item :
                  0);
    }
    else
      prev_subselect_item->used_tables_cache|=
        found_field->table->map;
    prev_subselect_item->const_item_cache= 0;
    mark_as_dependent(thd, last_select, current_sel, resolved_item,
                      dependent);
  }
}
3334 3335


3336
/**
3337 3338
  Search a GROUP BY clause for a field with a certain name.

3339 3340 3341
  Search the GROUP BY list for a column named as find_item. When searching
  preference is given to columns that are qualified with the same table (and
  database) name as the one being searched for.
3342

3343 3344
  @param find_item     the item being searched for
  @param group_list    GROUP BY clause
3345

3346
  @return
3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357
    - the found item on success
    - NULL if find_item is not in group_list
*/

static Item** find_field_in_group_list(Item *find_item, ORDER *group_list)
{
  const char *db_name;
  const char *table_name;
  const char *field_name;
  ORDER      *found_group= NULL;
  int         found_match_degree= 0;
3358
  Item_ident *cur_field;
3359
  int         cur_match_degree= 0;
3360
  char        name_buff[NAME_LEN+1];
3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371

  if (find_item->type() == Item::FIELD_ITEM ||
      find_item->type() == Item::REF_ITEM)
  {
    db_name=    ((Item_ident*) find_item)->db_name;
    table_name= ((Item_ident*) find_item)->table_name;
    field_name= ((Item_ident*) find_item)->field_name;
  }
  else
    return NULL;

3372 3373 3374 3375 3376 3377 3378 3379
  if (db_name && lower_case_table_names)
  {
    /* Convert database to lower case for comparison */
    strmake(name_buff, db_name, sizeof(name_buff)-1);
    my_casedn_str(files_charset_info, name_buff);
    db_name= name_buff;
  }

3380
  DBUG_ASSERT(field_name != 0);
3381 3382 3383

  for (ORDER *cur_group= group_list ; cur_group ; cur_group= cur_group->next)
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3384
    if ((*(cur_group->item))->real_item()->type() == Item::FIELD_ITEM)
3385
    {
3386
      cur_field= (Item_ident*) *cur_group->item;
3387 3388
      cur_match_degree= 0;
      
3389
      DBUG_ASSERT(cur_field->field_name != 0);
3390 3391 3392 3393 3394 3395 3396 3397 3398 3399

      if (!my_strcasecmp(system_charset_info,
                         cur_field->field_name, field_name))
        ++cur_match_degree;
      else
        continue;

      if (cur_field->table_name && table_name)
      {
        /* If field_name is qualified by a table name. */
3400
        if (my_strcasecmp(table_alias_charset, cur_field->table_name, table_name))
3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427
          /* Same field names, different tables. */
          return NULL;

        ++cur_match_degree;
        if (cur_field->db_name && db_name)
        {
          /* If field_name is also qualified by a database name. */
          if (strcmp(cur_field->db_name, db_name))
            /* Same field names, different databases. */
            return NULL;
          ++cur_match_degree;
        }
      }

      if (cur_match_degree > found_match_degree)
      {
        found_match_degree= cur_match_degree;
        found_group= cur_group;
      }
      else if (found_group && (cur_match_degree == found_match_degree) &&
               ! (*(found_group->item))->eq(cur_field, 0))
      {
        /*
          If the current resolve candidate matches equally well as the current
          best match, they must reference the same column, otherwise the field
          is ambiguous.
        */
3428 3429
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
                 find_item->full_name(), current_thd->where);
3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441
        return NULL;
      }
    }
  }

  if (found_group)
    return found_group->item;
  else
    return NULL;
}


3442
/**
3443 3444
  Resolve a column reference in a sub-select.

3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456
  Resolve a column reference (usually inside a HAVING clause) against the
  SELECT and GROUP BY clauses of the query described by 'select'. The name
  resolution algorithm searches both the SELECT and GROUP BY clauses, and in
  case of a name conflict prefers GROUP BY column names over SELECT names. If
  both clauses contain different fields with the same names, a warning is
  issued that name of 'ref' is ambiguous. We extend ANSI SQL in that when no
  GROUP BY column is found, then a HAVING name is resolved as a possibly
  derived SELECT column. This extension is allowed only if the
  MODE_ONLY_FULL_GROUP_BY sql mode isn't enabled.

  @param thd     current thread
  @param ref     column reference being resolved
3457
  @param select  the select that ref is resolved against
3458 3459

  @note
3460 3461
    The resolution procedure is:
    - Search for a column or derived column named col_ref_i [in table T_j]
3462
    in the SELECT clause of Q.
3463
    - Search for a column named col_ref_i [in table T_j]
3464
    in the GROUP BY clause of Q.
3465
    - If found different columns with the same name in GROUP BY and SELECT
3466 3467 3468 3469
    - issue a warning and return the GROUP BY column,
    - otherwise
    - if the MODE_ONLY_FULL_GROUP_BY mode is enabled return error
    - else return the found SELECT column.
3470 3471


3472 3473 3474 3475
  @return
    - NULL - there was an error, and the error was already reported
    - not_found_item - the item was not resolved, no error was reported
    - resolved item - if the item was resolved
3476 3477 3478 3479 3480 3481 3482 3483 3484 3485
*/

static Item**
resolve_ref_in_select_and_group(THD *thd, Item_ident *ref, SELECT_LEX *select)
{
  Item **group_by_ref= NULL;
  Item **select_ref= NULL;
  ORDER *group_list= (ORDER*) select->group_list.first;
  bool ambiguous_fields= FALSE;
  uint counter;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
3486
  enum_resolution_type resolution;
3487 3488 3489 3490 3491

  /*
    Search for a column or derived column named as 'ref' in the SELECT
    clause of the current select.
  */
3492 3493
  if (!(select_ref= find_item_in_list(ref, *(select->get_item_list()),
                                      &counter, REPORT_EXCEPT_NOT_FOUND,
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
3494
                                      &resolution)))
3495
    return NULL; /* Some error occurred. */
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
3496 3497
  if (resolution == RESOLVED_AGAINST_ALIAS)
    ref->alias_name_used= TRUE;
3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515

  /* If this is a non-aggregated field inside HAVING, search in GROUP BY. */
  if (select->having_fix_field && !ref->with_sum_func && group_list)
  {
    group_by_ref= find_field_in_group_list(ref, group_list);
    
    /* Check if the fields found in SELECT and GROUP BY are the same field. */
    if (group_by_ref && (select_ref != not_found_item) &&
        !((*group_by_ref)->eq(*select_ref, 0)))
    {
      ambiguous_fields= TRUE;
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_NON_UNIQ_ERROR,
                          ER(ER_NON_UNIQ_ERROR), ref->full_name(),
                          current_thd->where);

    }
  }

3516
  if (thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
3517
      select->having_fix_field  &&
3518 3519 3520 3521 3522 3523 3524 3525 3526 3527
      select_ref != not_found_item && !group_by_ref)
  {
    /*
      Report the error if fields was found only in the SELECT item list and
      the strict mode is enabled.
    */
    my_error(ER_NON_GROUPING_FIELD_USED, MYF(0),
             ref->name, "HAVING");
    return NULL;
  }
3528 3529 3530 3531
  if (select_ref != not_found_item || group_by_ref)
  {
    if (select_ref != not_found_item && !ambiguous_fields)
    {
3532
      DBUG_ASSERT(*select_ref != 0);
monty@mysql.com's avatar
monty@mysql.com committed
3533
      if (!select->ref_pointer_array[counter])
3534
      {
3535 3536
        my_error(ER_ILLEGAL_REFERENCE, MYF(0),
                 ref->name, "forward reference in item list");
3537 3538
        return NULL;
      }
monty@mysql.com's avatar
monty@mysql.com committed
3539
      DBUG_ASSERT((*select_ref)->fixed);
3540 3541
      return (select->ref_pointer_array + counter);
    }
monty@mishka.local's avatar
monty@mishka.local committed
3542
    if (group_by_ref)
3543
      return group_by_ref;
monty@mishka.local's avatar
monty@mishka.local committed
3544 3545
    DBUG_ASSERT(FALSE);
    return NULL; /* So there is no compiler warning. */
3546
  }
monty@mishka.local's avatar
monty@mishka.local committed
3547 3548

  return (Item**) not_found_item;
3549 3550 3551
}


3552
/**
3553 3554
  Resolve the name of an outer select column reference.

3555 3556
  The method resolves the column reference represented by 'this' as a column
  present in outer selects that contain current select.
3557

3558 3559 3560 3561 3562
  In prepared statements, because of cache, find_field_in_tables()
  can resolve fields even if they don't belong to current context.
  In this case this method only finds appropriate context and marks
  current select as dependent. The found reference of field should be
  provided in 'from_field'.
3563

3564 3565 3566 3567
  @param[in] thd             current thread
  @param[in,out] from_field  found field reference or (Field*)not_found_field
  @param[in,out] reference   view column if this item was resolved to a
    view column
3568

3569 3570 3571 3572 3573 3574 3575
  @note
    This is the inner loop of Item_field::fix_fields:
  @code
        for each outer query Q_k beginning from the inner-most one
        {
          search for a column or derived column named col_ref_i
          [in table T_j] in the FROM clause of Q_k;
3576

3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588
          if such a column is not found
            Search for a column or derived column named col_ref_i
            [in table T_j] in the SELECT and GROUP clauses of Q_k.
        }
  @endcode

  @retval
    1   column succefully resolved and fix_fields() should continue.
  @retval
    0   column fully fixed and fix_fields() should return FALSE
  @retval
    -1  error occured
3589
*/
3590

3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608
int
Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
{
  enum_parsing_place place= NO_MATTER;
  bool field_found= (*from_field != not_found_field);
  bool upward_lookup= FALSE;

  /*
    If there are outer contexts (outer selects, but current select is
    not derived table or view) try to resolve this reference in the
    outer contexts.

    We treat each subselect as a separate namespace, so that different
    subselects may contain columns with the same names. The subselects
    are searched starting from the innermost.
  */
  Name_resolution_context *last_checked_context= context;
  Item **ref= (Item **) not_found_item;
3609 3610
  SELECT_LEX *current_sel= (SELECT_LEX *) thd->lex->current_select;
  Name_resolution_context *outer_context= 0;
evgen@moonbone.local's avatar
evgen@moonbone.local committed
3611
  SELECT_LEX *select= 0;
3612 3613 3614 3615
  /* Currently derived tables cannot be correlated */
  if (current_sel->master_unit()->first_select()->linkage !=
      DERIVED_TABLE_TYPE)
    outer_context= context->outer_context;
3616 3617 3618 3619
  for (;
       outer_context;
       outer_context= outer_context->outer_context)
  {
3620
    select= outer_context->select_lex;
3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650
    Item_subselect *prev_subselect_item=
      last_checked_context->select_lex->master_unit()->item;
    last_checked_context= outer_context;
    upward_lookup= TRUE;

    place= prev_subselect_item->parsing_place;
    /*
      If outer_field is set, field was already found by first call
      to find_field_in_tables(). Only need to find appropriate context.
    */
    if (field_found && outer_context->select_lex !=
        cached_table->select_lex)
      continue;
    /*
      In case of a view, find_field_in_tables() writes the pointer to
      the found view field into '*reference', in other words, it
      substitutes this Item_field with the found expression.
    */
    if (field_found || (*from_field= find_field_in_tables(thd, this,
                                          outer_context->
                                            first_name_resolution_table,
                                          outer_context->
                                            last_name_resolution_table,
                                          reference,
                                          IGNORE_EXCEPT_NON_UNIQUE,
                                          TRUE, TRUE)) !=
        not_found_field)
    {
      if (*from_field)
      {
3651 3652 3653 3654 3655 3656 3657 3658 3659 3660
        if (thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
            select->cur_pos_in_select_list != UNDEF_POS)
        {
          /*
            As this is an outer field it should be added to the list of
            non aggregated fields of the outer select.
          */
          marker= select->cur_pos_in_select_list;
          select->non_agg_fields.push_back(this);
        }
3661 3662 3663 3664
        if (*from_field != view_ref_found)
        {
          prev_subselect_item->used_tables_cache|= (*from_field)->table->map;
          prev_subselect_item->const_item_cache= 0;
3665
          set_field(*from_field);
3666
          if (!last_checked_context->select_lex->having_fix_field &&
3667 3668
              select->group_list.elements &&
              (place == SELECT_LIST || place == IN_HAVING))
3669 3670 3671
          {
            Item_outer_ref *rf;
            /*
3672 3673 3674 3675 3676 3677 3678
              If an outer field is resolved in a grouping select then it
              is replaced for an Item_outer_ref object. Otherwise an
              Item_field object is used.
              The new Item_outer_ref object is saved in the inner_refs_list of
              the outer select. Here it is only created. It can be fixed only
              after the original field has been fixed and this is done in the
              fix_inner_refs() function.
3679
            */
3680 3681
            ;
            if (!(rf= new Item_outer_ref(context, this)))
3682
              return -1;
3683
            thd->change_item_tree(reference, rf);
3684
            select->inner_refs_list.push_back(rf);
3685
            rf->in_sum_func= thd->lex->in_sum_func;
3686
          }
gkodinov/kgeorge@magare.gmz's avatar
gkodinov/kgeorge@magare.gmz committed
3687 3688 3689 3690 3691
          /*
            A reference is resolved to a nest level that's outer or the same as
            the nest level of the enclosing set function : adjust the value of
            max_arg_level for the function if it's needed.
          */
3692
          if (thd->lex->in_sum_func &&
gkodinov/kgeorge@magare.gmz's avatar
gkodinov/kgeorge@magare.gmz committed
3693
              thd->lex->in_sum_func->nest_level >= select->nest_level)
3694
          {
3695
            Item::Type ref_type= (*reference)->type();
3696 3697 3698 3699 3700 3701
            set_if_bigger(thd->lex->in_sum_func->max_arg_level,
                          select->nest_level);
            set_field(*from_field);
            fixed= 1;
            mark_as_dependent(thd, last_checked_context->select_lex,
                              context->select_lex, this,
3702 3703
                              ((ref_type == REF_ITEM ||
                                ref_type == FIELD_ITEM) ?
3704 3705 3706 3707 3708 3709
                               (Item_ident*) (*reference) : 0));
            return 0;
          }
        }
        else
        {
3710
          Item::Type ref_type= (*reference)->type();
3711 3712 3713 3714 3715 3716
          prev_subselect_item->used_tables_cache|=
            (*reference)->used_tables();
          prev_subselect_item->const_item_cache&=
            (*reference)->const_item();
          mark_as_dependent(thd, last_checked_context->select_lex,
                            context->select_lex, this,
3717
                            ((ref_type == REF_ITEM || ref_type == FIELD_ITEM) ?
3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732
                             (Item_ident*) (*reference) :
                             0));
          /*
            A reference to a view field had been found and we
            substituted it instead of this Item (find_field_in_tables
            does it by assigning the new value to *reference), so now
            we can return from this function.
          */
          return 0;
        }
      }
      break;
    }

    /* Search in SELECT and GROUP lists of the outer select. */
3733
    if (place != IN_WHERE && place != IN_ON)
3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793
    {
      if (!(ref= resolve_ref_in_select_and_group(thd, this, select)))
        return -1; /* Some error occurred (e.g. ambiguous names). */
      if (ref != not_found_item)
      {
        DBUG_ASSERT(*ref && (*ref)->fixed);
        prev_subselect_item->used_tables_cache|= (*ref)->used_tables();
        prev_subselect_item->const_item_cache&= (*ref)->const_item();
        break;
      }
    }

    /*
      Reference is not found in this select => this subquery depend on
      outer select (or we just trying to find wrong identifier, in this
      case it does not matter which used tables bits we set)
    */
    prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
    prev_subselect_item->const_item_cache= 0;
  }

  DBUG_ASSERT(ref != 0);
  if (!*from_field)
    return -1;
  if (ref == not_found_item && *from_field == not_found_field)
  {
    if (upward_lookup)
    {
      // We can't say exactly what absent table or field
      my_error(ER_BAD_FIELD_ERROR, MYF(0), full_name(), thd->where);
    }
    else
    {
      /* Call find_field_in_tables only to report the error */
      find_field_in_tables(thd, this,
                           context->first_name_resolution_table,
                           context->last_name_resolution_table,
                           reference, REPORT_ALL_ERRORS,
                           !any_privileges &&
                           TRUE, TRUE);
    }
    return -1;
  }
  else if (ref != not_found_item)
  {
    Item *save;
    Item_ref *rf;

    /* Should have been checked in resolve_ref_in_select_and_group(). */
    DBUG_ASSERT(*ref && (*ref)->fixed);
    /*
      Here, a subset of actions performed by Item_ref::set_properties
      is not enough. So we pass ptr to NULL into Item_[direct]_ref
      constructor, so no initialization is performed, and call 
      fix_fields() below.
    */
    save= *ref;
    *ref= NULL;                             // Don't call set_properties()
    rf= (place == IN_HAVING ?
         new Item_ref(context, ref, (char*) table_name,
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
3794
                      (char*) field_name, alias_name_used) :
3795
         (!select->group_list.elements ?
3796
         new Item_direct_ref(context, ref, (char*) table_name,
3797 3798 3799
                             (char*) field_name, alias_name_used) :
         new Item_outer_ref(context, ref, (char*) table_name,
                            (char*) field_name, alias_name_used)));
3800 3801 3802
    *ref= save;
    if (!rf)
      return -1;
3803 3804 3805 3806 3807 3808

    if (place != IN_HAVING && select->group_list.elements)
    {
      outer_context->select_lex->inner_refs_list.push_back((Item_outer_ref*)rf);
      ((Item_outer_ref*)rf)->in_sum_func= thd->lex->in_sum_func;
    }
3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826
    thd->change_item_tree(reference, rf);
    /*
      rf is Item_ref => never substitute other items (in this case)
      during fix_fields() => we can use rf after fix_fields()
    */
    DBUG_ASSERT(!rf->fixed);                // Assured by Item_ref()
    if (rf->fix_fields(thd, reference) || rf->check_cols(1))
      return -1;

    mark_as_dependent(thd, last_checked_context->select_lex,
                      context->select_lex, this,
                      rf);
    return 0;
  }
  else
  {
    mark_as_dependent(thd, last_checked_context->select_lex,
                      context->select_lex,
3827
                      this, (Item_ident*)*reference);
3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850
    if (last_checked_context->select_lex->having_fix_field)
    {
      Item_ref *rf;
      rf= new Item_ref(context,
                       (cached_table->db[0] ? cached_table->db : 0),
                       (char*) cached_table->alias, (char*) field_name);
      if (!rf)
        return -1;
      thd->change_item_tree(reference, rf);
      /*
        rf is Item_ref => never substitute other items (in this case)
        during fix_fields() => we can use rf after fix_fields()
      */
      DBUG_ASSERT(!rf->fixed);                // Assured by Item_ref()
      if (rf->fix_fields(thd, reference) || rf->check_cols(1))
        return -1;
      return 0;
    }
  }
  return 1;
}


3851
/**
3852 3853
  Resolve the name of a column reference.

3854 3855 3856
  The method resolves the column reference represented by 'this' as a column
  present in one of: FROM clause, SELECT clause, GROUP BY clause of a query
  Q, or in outer queries that contain Q.
3857

3858 3859
  The name resolution algorithm used is (where [T_j] is an optional table
  name that qualifies the column name):
3860

3861 3862 3863 3864 3865
  @code
    resolve_column_reference([T_j].col_ref_i)
    {
      search for a column or derived column named col_ref_i
      [in table T_j] in the FROM clause of Q;
3866

3867 3868
      if such a column is NOT found AND    // Lookup in outer queries.
         there are outer queries
3869
      {
3870
        for each outer query Q_k beginning from the inner-most one
3871
        {
3872 3873
          search for a column or derived column named col_ref_i
          [in table T_j] in the FROM clause of Q_k;
3874

3875 3876 3877
          if such a column is not found
            Search for a column or derived column named col_ref_i
            [in table T_j] in the SELECT and GROUP clauses of Q_k.
3878 3879
        }
      }
3880 3881
    }
  @endcode
3882 3883 3884 3885

    Notice that compared to Item_ref::fix_fields, here we first search the FROM
    clause, and then we search the SELECT and GROUP BY clauses.

3886 3887 3888 3889 3890
  @param[in]     thd        current thread
  @param[in,out] reference  view column if this item was resolved to a
    view column

  @retval
3891
    TRUE  if error
3892
  @retval
3893 3894 3895
    FALSE on success
*/

3896
bool Item_field::fix_fields(THD *thd, Item **reference)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3897
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
3898
  DBUG_ASSERT(fixed == 0);
3899 3900 3901
  Field *from_field= (Field *)not_found_field;
  bool outer_fixed= false;

3902
  if (!field)					// If field is not checked
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3903
  {
3904 3905 3906 3907 3908
    /*
      In case of view, find_field_in_tables() write pointer to view field
      expression to 'reference', i.e. it substitute that expression instead
      of this Item_field
    */
3909 3910 3911
    if ((from_field= find_field_in_tables(thd, this,
                                          context->first_name_resolution_table,
                                          context->last_name_resolution_table,
3912
                                          reference,
3913 3914 3915
                                          thd->lex->use_only_table_context ?
                                            REPORT_ALL_ERRORS : 
                                            IGNORE_EXCEPT_NON_UNIQUE,
3916
                                          !any_privileges,
3917
                                          TRUE)) ==
3918
	not_found_field)
3919
    {
3920
      int ret;
3921 3922 3923 3924
      /* Look up in current select's item_list to find aliased fields */
      if (thd->lex->current_select->is_item_list_lookup)
      {
        uint counter;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
3925
        enum_resolution_type resolution;
3926 3927
        Item** res= find_item_in_list(this, thd->lex->current_select->item_list,
                                      &counter, REPORT_EXCEPT_NOT_FOUND,
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
3928
                                      &resolution);
3929 3930
        if (!res)
          return 1;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
3931 3932
        if (resolution == RESOLVED_AGAINST_ALIAS)
          alias_name_used= TRUE;
3933
        if (res != (Item **)not_found_item)
3934
        {
3935 3936 3937
          if ((*res)->type() == Item::FIELD_ITEM)
          {
            /*
3938 3939 3940 3941
              It's an Item_field referencing another Item_field in the select
              list.
              Use the field from the Item_field in the select list and leave
              the Item_field instance in place.
3942
            */
3943

3944
            Field *new_field= (*((Item_field**)res))->field;
3945

3946
            if (new_field == NULL)
3947 3948 3949 3950 3951 3952 3953
            {
              /* The column to which we link isn't valid. */
              my_error(ER_BAD_FIELD_ERROR, MYF(0), (*res)->name, 
                       current_thd->where);
              return(1);
            }

3954
            set_field(new_field);
3955 3956 3957 3958 3959 3960 3961 3962 3963
            return 0;
          }
          else
          {
            /*
              It's not an Item_field in the select list so we must make a new
              Item_ref to point to the Item in the select list and replace the
              Item_field created by the parser with the new Item_ref.
            */
gkodinov@dl145s.mysql.com's avatar
gkodinov@dl145s.mysql.com committed
3964
            Item_ref *rf= new Item_ref(context, db_name,table_name,field_name);
3965 3966
            if (!rf)
              return 1;
gkodinov@dl145s.mysql.com's avatar
gkodinov@dl145s.mysql.com committed
3967
            thd->change_item_tree(reference, rf);
3968 3969 3970 3971 3972
            /*
              Because Item_ref never substitutes itself with other items 
              in Item_ref::fix_fields(), we can safely use the original 
              pointer to it even after fix_fields()
             */
gkodinov@dl145s.mysql.com's avatar
gkodinov@dl145s.mysql.com committed
3973
            return rf->fix_fields(thd, reference) ||  rf->check_cols(1);
3974
          }
3975 3976
        }
      }
3977 3978 3979 3980 3981
      if ((ret= fix_outer_field(thd, &from_field, reference)) < 0)
        goto error;
      else if (!ret)
        return FALSE;
      outer_fixed= TRUE;
3982
    }
3983
    else if (!from_field)
3984
      goto error;
3985

bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3986 3987 3988 3989
    /*
      if it is not expression from merged VIEW we will set this field.

      We can leave expression substituted from view for next PS/SP rexecution
3990
      (i.e. do not register this substitution for reverting on cleanup()
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3991
      (register_item_tree_changing())), because this subtree will be
3992
      fix_field'ed during setup_tables()->setup_underlying() (i.e. before
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
3993 3994 3995 3996 3997
      all other expressions of query, and references on tables which do
      not present in query will not make problems.

      Also we suppose that view can't be changed during PS/SP life.
    */
3998 3999 4000
    if (from_field == view_ref_found)
      return FALSE;

4001
    if (!outer_fixed && cached_table && cached_table->select_lex &&
4002 4003
        context->select_lex &&
        cached_table->select_lex != context->select_lex)
4004 4005 4006 4007
    {
      int ret;
      if ((ret= fix_outer_field(thd, &from_field, reference)) < 0)
        goto error;
4008
      if (!ret)
4009
        return FALSE;
4010
      outer_fixed= 1;
4011 4012
    }

4013
    set_field(from_field);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4014 4015 4016 4017 4018
    if (thd->lex->in_sum_func &&
        thd->lex->in_sum_func->nest_level == 
        thd->lex->current_select->nest_level)
      set_if_bigger(thd->lex->in_sum_func->max_arg_level,
                    thd->lex->current_select->nest_level);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4019
  }
4020
  else if (thd->mark_used_columns != MARK_COLUMNS_NONE)
4021
  {
4022
    TABLE *table= field->table;
4023 4024
    MY_BITMAP *current_bitmap, *other_bitmap;
    if (thd->mark_used_columns == MARK_COLUMNS_READ)
4025
    {
4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039
      current_bitmap= table->read_set;
      other_bitmap=   table->write_set;
    }
    else
    {
      current_bitmap= table->write_set;
      other_bitmap=   table->read_set;
    }
    if (!bitmap_fast_test_and_set(current_bitmap, field->field_index))
    {
      if (!bitmap_is_set(other_bitmap, field->field_index))
      {
        /* First usage of column */
        table->used_fields++;                     // Used to optimize loops
4040
        /* purecov: begin inspected */
4041
        table->covering_keys.intersect(field->part_of_key);
4042
        /* purecov: end */
4043
      }
4044
    }
4045
  }
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  if (any_privileges)
  {
    char *db, *tab;
    if (cached_table->view)
    {
      db= cached_table->view_db.str;
      tab= cached_table->view_name.str;
    }
    else
    {
      db= cached_table->db;
4058
      tab= cached_table->table_name;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4059 4060 4061 4062 4063
    }
    if (!(have_privileges= (get_column_grant(thd, &field->table->grant,
                                             db, tab, field_name) &
                            VIEW_ANY_ACL)))
    {
4064
      my_error(ER_COLUMNACCESS_DENIED_ERROR, MYF(0),
4065 4066
               "ANY", thd->security_ctx->priv_user,
               thd->security_ctx->host_or_ip, field_name, tab);
4067
      goto error;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
4068 4069 4070
    }
  }
#endif
4071
  fixed= 1;
4072 4073 4074 4075 4076 4077 4078
  if (thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
      !outer_fixed && !thd->lex->in_sum_func &&
      thd->lex->current_select->cur_pos_in_select_list != UNDEF_POS)
  {
    thd->lex->current_select->non_agg_fields.push_back(this);
    marker= thd->lex->current_select->cur_pos_in_select_list;
  }
4079
  return FALSE;
4080 4081 4082 4083

error:
  context->process_error(thd);
  return TRUE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4084 4085
}

4086 4087 4088 4089 4090 4091 4092 4093

Item *Item_field::safe_charset_converter(CHARSET_INFO *tocs)
{
  no_const_subst= 1;
  return Item::safe_charset_converter(tocs);
}


hf@deer.(none)'s avatar
hf@deer.(none) committed
4094 4095
void Item_field::cleanup()
{
4096
  DBUG_ENTER("Item_field::cleanup");
hf@deer.(none)'s avatar
hf@deer.(none) committed
4097
  Item_ident::cleanup();
4098 4099
  /*
    Even if this object was created by direct link to field in setup_wild()
4100
    it will be linked correctly next time by name of field and table alias.
4101 4102
    I.e. we can drop 'field'.
   */
4103
  field= result_field= 0;
4104
  null_value= FALSE;
4105
  DBUG_VOID_RETURN;
4106
}
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4107

4108 4109
/**
  Find a field among specified multiple equalities.
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4110

4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123
  The function first searches the field among multiple equalities
  of the current level (in the cond_equal->current_level list).
  If it fails, it continues searching in upper levels accessed
  through a pointer cond_equal->upper_levels.
  The search terminates as soon as a multiple equality containing 
  the field is found. 

  @param cond_equal   reference to list of multiple equalities where
                      the field (this object) is to be looked for

  @return
    - First Item_equal containing the field, if success
    - 0, otherwise
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4124
*/
4125

4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146
Item_equal *Item_field::find_item_equal(COND_EQUAL *cond_equal)
{
  Item_equal *item= 0;
  while (cond_equal)
  {
    List_iterator_fast<Item_equal> li(cond_equal->current_level);
    while ((item= li++))
    {
      if (item->contains(field))
        return item;
    }
    /* 
      The field is not found in any of the multiple equalities
      of the current level. Look for it in upper levels
    */
    cond_equal= cond_equal->upper_levels;
  }
  return 0;
}


4147 4148
/**
  Check whether a field can be substituted by an equal item.
4149

4150 4151
  The function checks whether a substitution of the field
  occurrence for an equal item is valid.
4152

4153 4154 4155 4156
  @param arg   *arg != NULL <-> the field is in the context where
               substitution for an equal item is valid

  @note
4157
    The following statement is not always true:
4158
  @n
4159
    x=y => F(x)=F(x/y).
4160
  @n
4161
    This means substitution of an item for an equal item not always
4162 4163 4164 4165 4166
    yields an equavalent condition. Here's an example:
    @code
    'a'='a '
    (LENGTH('a')=1) != (LENGTH('a ')=2)
  @endcode
4167 4168
    Such a substitution is surely valid if either the substituted
    field is not of a STRING type or if it is an argument of
4169
    a comparison predicate.
4170

4171
  @retval
4172
    TRUE   substitution is valid
4173
  @retval
4174 4175 4176
    FALSE  otherwise
*/

4177
bool Item_field::subst_argument_checker(uchar **arg)
4178 4179 4180 4181 4182
{
  return (result_type() != STRING_RESULT) || (*arg);
}


4183
/**
4184
  Set a pointer to the multiple equality the field reference belongs to
4185
  (if any).
4186

4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198
  The function looks for a multiple equality containing the field item
  among those referenced by arg.
  In the case such equality exists the function does the following.
  If the found multiple equality contains a constant, then the field
  reference is substituted for this constant, otherwise it sets a pointer
  to the multiple equality in the field item.


  @param arg    reference to list of multiple equalities where
                the field (this object) is to be looked for

  @note
4199
    This function is supposed to be called as a callback parameter in calls
4200
    of the compile method.
4201

4202 4203 4204
  @return
    - pointer to the replacing constant item, if the field item was substituted
    - pointer to the field item, otherwise.
4205
*/
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4206

4207
Item *Item_field::equal_fields_propagator(uchar *arg)
4208 4209 4210 4211 4212 4213 4214
{
  if (no_const_subst)
    return this;
  item_equal= find_item_equal((COND_EQUAL *) arg);
  Item *item= 0;
  if (item_equal)
    item= item_equal->get_const();
4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225
  /*
    Disable const propagation for items used in different comparison contexts.
    This must be done because, for example, Item_hex_string->val_int() is not
    the same as (Item_hex_string->val_str() in BINARY column)->val_int().
    We cannot simply disable the replacement in a particular context (
    e.g. <bin_col> = <int_col> AND <bin_col> = <hex_string>) since
    Items don't know the context they are in and there are functions like 
    IF (<hex_string>, 'yes', 'no').
    The same problem occurs when comparing a DATE/TIME field with a
    DATE/TIME represented as an int and as a string.
  */
4226 4227
  if (!item ||
      (cmp_context != (Item_result)-1 && item->cmp_context != cmp_context))
4228 4229 4230 4231 4232
    item= this;
  return item;
}


4233 4234 4235 4236
/**
  Mark the item to not be part of substitution if it's not a binary item.

  See comments in Arg_comparator::set_compare_func() for details.
4237 4238
*/

4239
bool Item_field::set_no_const_sub(uchar *arg)
4240 4241 4242
{
  if (field->charset() != &my_charset_bin)
    no_const_subst=1;
4243
  return FALSE;
4244 4245 4246
}


4247
/**
4248
  Replace an Item_field for an equal Item_field that evaluated earlier
4249
  (if any).
4250

4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262
  The function returns a pointer to an item that is taken from
  the very beginning of the item_equal list which the Item_field
  object refers to (belongs to) unless item_equal contains  a constant
  item. In this case the function returns this constant item, 
  (if the substitution does not require conversion).   
  If the Item_field object does not refer any Item_equal object
  'this' is returned .

  @param arg   a dummy parameter, is not used here


  @note
4263
    This function is supposed to be called as a callback parameter in calls
4264
    of the thransformer method.
4265

4266 4267 4268 4269
  @return
    - pointer to a replacement Item_field if there is a better equal item or
      a pointer to a constant equal item;
    - this - otherwise.
4270 4271
*/

4272
Item *Item_field::replace_equal_field(uchar *arg)
4273 4274 4275
{
  if (item_equal)
  {
4276 4277 4278 4279 4280 4281 4282 4283
    Item *const_item= item_equal->get_const();
    if (const_item)
    {
      if (cmp_context != (Item_result)-1 &&
          const_item->cmp_context != cmp_context)
        return this;
      return const_item;
    }
4284
    Item_field *subst= item_equal->get_first();
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
4285
    if (subst && !field->eq(subst->field))
4286
      return subst;
4287
  }
4288
  return this;
hf@deer.(none)'s avatar
hf@deer.(none) committed
4289
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4290

4291

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4292
void Item::init_make_field(Send_field *tmp_field,
4293
			   enum enum_field_types field_type_arg)
4294
{
4295
  char *empty_name= (char*) "";
4296
  tmp_field->db_name=		empty_name;
4297 4298 4299 4300
  tmp_field->org_table_name=	empty_name;
  tmp_field->org_col_name=	empty_name;
  tmp_field->table_name=	empty_name;
  tmp_field->col_name=		name;
4301
  tmp_field->charsetnr=         collation.collation->number;
4302 4303 4304
  tmp_field->flags=             (maybe_null ? 0 : NOT_NULL_FLAG) | 
                                (my_binary_compare(collation.collation) ?
                                 BINARY_FLAG : 0);
4305
  tmp_field->type=              field_type_arg;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4306 4307
  tmp_field->length=max_length;
  tmp_field->decimals=decimals;
4308 4309
  if (unsigned_flag)
    tmp_field->flags |= UNSIGNED_FLAG;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4310 4311
}

4312
void Item::make_field(Send_field *tmp_field)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4313
{
4314
  init_make_field(tmp_field, field_type());
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4315 4316 4317
}


4318
enum_field_types Item::string_field_type() const
4319
{
4320
  enum_field_types f_type= MYSQL_TYPE_VAR_STRING;
4321
  if (max_length >= 16777216)
4322
    f_type= MYSQL_TYPE_LONG_BLOB;
4323
  else if (max_length >= 65536)
4324
    f_type= MYSQL_TYPE_MEDIUM_BLOB;
4325
  return f_type;
4326 4327 4328 4329 4330 4331
}


void Item_empty_string::make_field(Send_field *tmp_field)
{
  init_make_field(tmp_field, string_field_type());
4332 4333
}

4334

4335
enum_field_types Item::field_type() const
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4336
{
4337
  switch (result_type()) {
4338
  case STRING_RESULT:  return string_field_type();
4339 4340 4341
  case INT_RESULT:     return MYSQL_TYPE_LONGLONG;
  case DECIMAL_RESULT: return MYSQL_TYPE_NEWDECIMAL;
  case REAL_RESULT:    return MYSQL_TYPE_DOUBLE;
4342 4343 4344
  case ROW_RESULT:
  default:
    DBUG_ASSERT(0);
4345 4346
    return MYSQL_TYPE_VARCHAR;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4347 4348
}

4349

4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364
bool Item::is_datetime()
{
  switch (field_type())
  {
    case MYSQL_TYPE_DATE:
    case MYSQL_TYPE_DATETIME:
    case MYSQL_TYPE_TIMESTAMP:
      return TRUE;
    default:
      break;
  }
  return FALSE;
}


4365
String *Item::check_well_formed_result(String *str, bool send_error)
4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380
{
  /* Check whether we got a well-formed string */
  CHARSET_INFO *cs= str->charset();
  int well_formed_error;
  uint wlen= cs->cset->well_formed_len(cs,
                                       str->ptr(), str->ptr() + str->length(),
                                       str->length(), &well_formed_error);
  if (wlen < str->length())
  {
    THD *thd= current_thd;
    char hexbuf[7];
    enum MYSQL_ERROR::enum_warning_level level;
    uint diff= str->length() - wlen;
    set_if_smaller(diff, 3);
    octet2hex(hexbuf, str->ptr() + wlen, diff);
4381 4382 4383 4384 4385 4386 4387 4388
    if (send_error)
    {
      my_error(ER_INVALID_CHARACTER_STRING, MYF(0),
               cs->csname,  hexbuf);
      return 0;
    }
    if ((thd->variables.sql_mode &
         (MODE_STRICT_TRANS_TABLES | MODE_STRICT_ALL_TABLES)))
4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405
    {
      level= MYSQL_ERROR::WARN_LEVEL_ERROR;
      null_value= 1;
      str= 0;
    }
    else
    {
      level= MYSQL_ERROR::WARN_LEVEL_WARN;
      str->length(wlen);
    }
    push_warning_printf(thd, level, ER_INVALID_CHARACTER_STRING,
                        ER(ER_INVALID_CHARACTER_STRING), cs->csname, hexbuf);
  }
  return str;
}


4406 4407
/**
  Create a field to hold a string value from an item.
4408

4409 4410 4411
  If max_length > CONVERT_IF_BIGGER_TO_BLOB create a blob @n
  If max_length > 0 create a varchar @n
  If max_length == 0 create a CHAR(0) 
4412

4413
  @param table		Table for which the field is created
4414 4415 4416 4417
*/

Field *Item::make_string_field(TABLE *table)
{
4418
  Field *field;
4419 4420
  DBUG_ASSERT(collation.collation);
  if (max_length/collation.collation->mbmaxlen > CONVERT_IF_BIGGER_TO_BLOB)
4421
    field= new Field_blob(max_length, maybe_null, name,
4422
                          collation.collation);
4423
  /* Item_type_holder holds the exact type, do not change it */
4424
  else if (max_length > 0 &&
4425
      (type() != Item::TYPE_HOLDER || field_type() != MYSQL_TYPE_STRING))
4426
    field= new Field_varstring(max_length, maybe_null, name, table->s,
4427
                               collation.collation);
4428 4429 4430 4431 4432 4433
  else
    field= new Field_string(max_length, maybe_null, name,
                            collation.collation);
  if (field)
    field->init(table);
  return field;
4434 4435 4436
}


4437 4438
/**
  Create a field based on field_type of argument.
4439 4440

  For now, this is only used to create a field for
4441
  IFNULL(x,something) and time functions
4442

4443 4444 4445 4446
  @retval
    NULL  error
  @retval
    \#    Created field
4447 4448
*/

4449
Field *Item::tmp_table_field_from_field_type(TABLE *table, bool fixed_length)
4450
{
4451 4452 4453 4454
  /*
    The field functions defines a field to be not null if null_ptr is not 0
  */
  uchar *null_ptr= maybe_null ? (uchar*) "" : 0;
4455
  Field *field;
4456 4457

  switch (field_type()) {
4458
  case MYSQL_TYPE_DECIMAL:
4459
  case MYSQL_TYPE_NEWDECIMAL:
4460
    field= new Field_new_decimal((uchar*) 0, max_length, null_ptr, 0,
4461
                                 Field::NONE, name, decimals, 0,
4462
                                 unsigned_flag);
4463
    break;
4464
  case MYSQL_TYPE_TINY:
4465
    field= new Field_tiny((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4466 4467
			  name, 0, unsigned_flag);
    break;
4468
  case MYSQL_TYPE_SHORT:
4469
    field= new Field_short((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4470 4471
			   name, 0, unsigned_flag);
    break;
4472
  case MYSQL_TYPE_LONG:
4473
    field= new Field_long((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4474 4475
			  name, 0, unsigned_flag);
    break;
4476 4477
#ifdef HAVE_LONG_LONG
  case MYSQL_TYPE_LONGLONG:
4478
    field= new Field_longlong((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4479 4480
			      name, 0, unsigned_flag);
    break;
4481
#endif
4482
  case MYSQL_TYPE_FLOAT:
4483
    field= new Field_float((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4484 4485
			   name, decimals, 0, unsigned_flag);
    break;
4486
  case MYSQL_TYPE_DOUBLE:
4487
    field= new Field_double((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4488 4489
			    name, decimals, 0, unsigned_flag);
    break;
4490
  case MYSQL_TYPE_NULL:
4491
    field= new Field_null((uchar*) 0, max_length, Field::NONE,
4492 4493
			  name, &my_charset_bin);
    break;
4494
  case MYSQL_TYPE_INT24:
4495
    field= new Field_medium((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4496 4497
			    name, 0, unsigned_flag);
    break;
4498
  case MYSQL_TYPE_NEWDATE:
4499
  case MYSQL_TYPE_DATE:
4500
    field= new Field_newdate(maybe_null, name, &my_charset_bin);
4501
    break;
4502
  case MYSQL_TYPE_TIME:
4503 4504
    field= new Field_time(maybe_null, name, &my_charset_bin);
    break;
4505
  case MYSQL_TYPE_TIMESTAMP:
evgen@sunlight.local's avatar
evgen@sunlight.local committed
4506 4507
    field= new Field_timestamp(maybe_null, name, &my_charset_bin);
    break;
4508
  case MYSQL_TYPE_DATETIME:
4509 4510
    field= new Field_datetime(maybe_null, name, &my_charset_bin);
    break;
4511
  case MYSQL_TYPE_YEAR:
4512
    field= new Field_year((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4513 4514
			  name);
    break;
ramil@mysql.com's avatar
ramil@mysql.com committed
4515
  case MYSQL_TYPE_BIT:
4516
    field= new Field_bit_as_char(NULL, max_length, null_ptr, 0,
4517 4518
                                 Field::NONE, name);
    break;
4519
  default:
4520
    /* This case should never be chosen */
4521 4522
    DBUG_ASSERT(0);
    /* If something goes awfully wrong, it's better to get a string than die */
4523 4524 4525 4526 4527 4528 4529 4530
  case MYSQL_TYPE_STRING:
    if (fixed_length && max_length < CONVERT_IF_BIGGER_TO_BLOB)
    {
      field= new Field_string(max_length, maybe_null, name,
                              collation.collation);
      break;
    }
    /* Fall through to make_string_field() */
4531 4532
  case MYSQL_TYPE_ENUM:
  case MYSQL_TYPE_SET:
4533
  case MYSQL_TYPE_VAR_STRING:
4534
  case MYSQL_TYPE_VARCHAR:
4535
    return make_string_field(table);
4536 4537 4538 4539
  case MYSQL_TYPE_TINY_BLOB:
  case MYSQL_TYPE_MEDIUM_BLOB:
  case MYSQL_TYPE_LONG_BLOB:
  case MYSQL_TYPE_BLOB:
4540
    if (this->type() == Item::TYPE_HOLDER)
evgen@sunlight.local's avatar
evgen@sunlight.local committed
4541 4542
      field= new Field_blob(max_length, maybe_null, name, collation.collation,
                            1);
4543
    else
evgen@sunlight.local's avatar
evgen@sunlight.local committed
4544
      field= new Field_blob(max_length, maybe_null, name, collation.collation);
4545
    break;					// Blob handled outside of case
4546
#ifdef HAVE_SPATIAL
gkodinov/kgeorge@magare.gmz's avatar
gkodinov/kgeorge@magare.gmz committed
4547
  case MYSQL_TYPE_GEOMETRY:
4548 4549
    field= new Field_geom(max_length, maybe_null,
                          name, table->s, get_geometry_type());
4550
#endif /* HAVE_SPATIAL */
4551
  }
4552 4553 4554
  if (field)
    field->init(table);
  return field;
4555 4556
}

4557

4558 4559
/* ARGSUSED */
void Item_field::make_field(Send_field *tmp_field)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4560
{
4561
  field->make_field(tmp_field);
4562
  DBUG_ASSERT(tmp_field->table_name != 0);
4563 4564
  if (name)
    tmp_field->col_name=name;			// Use user supplied name
4565 4566 4567 4568
  if (table_name)
    tmp_field->table_name= table_name;
  if (db_name)
    tmp_field->db_name= db_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4569 4570
}

4571

4572 4573
/**
  Set a field's value from a item.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4574 4575 4576 4577 4578 4579 4580
*/

void Item_field::save_org_in_field(Field *to)
{
  if (field->is_null())
  {
    null_value=1;
4581
    set_field_to_null_with_conversions(to, 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4582 4583 4584 4585 4586 4587 4588 4589 4590
  }
  else
  {
    to->set_notnull();
    field_conv(to,field);
    null_value=0;
  }
}

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4591
int Item_field::save_in_field(Field *to, bool no_conversions)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4592
{
4593
  int res;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4594 4595 4596
  if (result_field->is_null())
  {
    null_value=1;
4597
    res= set_field_to_null_with_conversions(to, no_conversions);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4598 4599 4600 4601
  }
  else
  {
    to->set_notnull();
4602
    res= field_conv(to,result_field);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4603 4604
    null_value=0;
  }
4605
  return res;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4606 4607
}

4608

4609 4610
/**
  Store null in field.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4611

4612 4613
  This is used on INSERT.
  Allow NULL to be inserted in timestamp and auto_increment values.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4614

4615
  @param field		Field where we want to store NULL
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4616

4617 4618 4619 4620 4621
  @retval
    0   ok
  @retval
    1   Field doesn't support NULL values and can't handle 'field = NULL'
*/
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4622

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4623
int Item_null::save_in_field(Field *field, bool no_conversions)
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4624
{
4625
  return set_field_to_null_with_conversions(field, no_conversions);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4626 4627 4628
}


4629 4630
/**
  Store null in field.
4631

4632
  @param field		Field where we want to store NULL
4633

4634
  @retval
4635
    0	 OK
4636
  @retval
4637
    1	 Field doesn't support NULL values
4638
*/
4639

monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
4640
int Item_null::save_safe_in_field(Field *field)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4641 4642 4643 4644 4645
{
  return set_field_to_null(field);
}


4646 4647 4648 4649 4650 4651
/*
  This implementation can lose str_value content, so if the
  Item uses str_value to store something, it should
  reimplement it's ::save_in_field() as Item_string, for example, does
*/

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4652
int Item::save_in_field(Field *field, bool no_conversions)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4653
{
4654
  int error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4655 4656 4657 4658 4659
  if (result_type() == STRING_RESULT ||
      result_type() == REAL_RESULT &&
      field->result_type() == STRING_RESULT)
  {
    String *result;
4660
    CHARSET_INFO *cs= collation.collation;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4661
    char buff[MAX_FIELD_WIDTH];		// Alloc buffer for small columns
monty@mysql.com's avatar
monty@mysql.com committed
4662
    str_value.set_quick(buff, sizeof(buff), cs);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4663 4664
    result=val_str(&str_value);
    if (null_value)
4665
    {
monty@mysql.com's avatar
monty@mysql.com committed
4666
      str_value.set_quick(0, 0, cs);
4667
      return set_field_to_null_with_conversions(field, no_conversions);
4668
    }
4669 4670 4671

    /* NOTE: If null_value == FALSE, "result" must be not NULL.  */

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4672
    field->set_notnull();
4673
    error=field->store(result->ptr(),result->length(),cs);
4674
    str_value.set_quick(0, 0, cs);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4675 4676 4677
  }
  else if (result_type() == REAL_RESULT)
  {
4678
    double nr= val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4679 4680 4681
    if (null_value)
      return set_field_to_null(field);
    field->set_notnull();
4682
    error=field->store(nr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4683
  }
4684 4685 4686 4687 4688
  else if (result_type() == DECIMAL_RESULT)
  {
    my_decimal decimal_value;
    my_decimal *value= val_decimal(&decimal_value);
    if (null_value)
4689
      return set_field_to_null_with_conversions(field, no_conversions);
4690 4691 4692
    field->set_notnull();
    error=field->store_decimal(value);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4693 4694 4695 4696
  else
  {
    longlong nr=val_int();
    if (null_value)
4697
      return set_field_to_null_with_conversions(field, no_conversions);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4698
    field->set_notnull();
4699
    error=field->store(nr, unsigned_flag);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4700
  }
4701
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4702 4703
}

4704

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4705
int Item_string::save_in_field(Field *field, bool no_conversions)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4706 4707 4708
{
  String *result;
  result=val_str(&str_value);
4709
  return save_str_value_in_field(field, result);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4710 4711
}

4712

monty@mysql.com's avatar
monty@mysql.com committed
4713
int Item_uint::save_in_field(Field *field, bool no_conversions)
4714
{
4715
  /* Item_int::save_in_field handles both signed and unsigned. */
monty@mysql.com's avatar
monty@mysql.com committed
4716
  return Item_int::save_in_field(field, no_conversions);
4717 4718
}

monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4719 4720

int Item_int::save_in_field(Field *field, bool no_conversions)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4721 4722 4723 4724 4725
{
  longlong nr=val_int();
  if (null_value)
    return set_field_to_null(field);
  field->set_notnull();
4726
  return field->store(nr, unsigned_flag);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4727 4728
}

4729 4730 4731 4732 4733 4734 4735 4736

int Item_decimal::save_in_field(Field *field, bool no_conversions)
{
  field->set_notnull();
  return field->store_decimal(&decimal_value);
}


4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752
bool Item_int::eq(const Item *arg, bool binary_cmp) const
{
  /* No need to check for null value as basic constant can't be NULL */
  if (arg->basic_const_item() && arg->type() == type())
  {
    /*
      We need to cast off const to call val_int(). This should be OK for
      a basic constant.
    */
    Item *item= (Item*) arg;
    return item->val_int() == value && item->unsigned_flag == unsigned_flag;
  }
  return FALSE;
}


4753
Item *Item_int_with_ref::clone_item()
4754
{
4755
  DBUG_ASSERT(ref->const_item());
4756 4757 4758 4759 4760 4761 4762 4763 4764 4765
  /*
    We need to evaluate the constant to make sure it works with
    parameter markers.
  */
  return (ref->unsigned_flag ?
          new Item_uint(ref->name, ref->val_int(), ref->max_length) :
          new Item_int(ref->name, ref->val_int(), ref->max_length));
}


bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4766 4767
Item_num *Item_uint::neg()
{
4768
  Item_decimal *item= new Item_decimal(value, 1);
4769
  return item->neg();
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4770
}
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
4771

4772

4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795
static uint nr_of_decimals(const char *str, const char *end)
{
  const char *decimal_point;

  /* Find position for '.' */
  for (;;)
  {
    if (str == end)
      return 0;
    if (*str == 'e' || *str == 'E')
      return NOT_FIXED_DEC;    
    if (*str++ == '.')
      break;
  }
  decimal_point= str;
  for (; my_isdigit(system_charset_info, *str) ; str++)
    ;
  if (*str == 'e' || *str == 'E')
    return NOT_FIXED_DEC;
  return (uint) (str - decimal_point);
}


4796
/**
4797 4798 4799 4800
  This function is only called during parsing. We will signal an error if
  value is not a true double value (overflow)
*/

4801
Item_float::Item_float(const char *str_arg, uint length)
4802 4803
{
  int error;
4804 4805 4806
  char *end_not_used;
  value= my_strntod(&my_charset_bin, (char*) str_arg, length, &end_not_used,
                    &error);
4807 4808 4809 4810 4811 4812 4813
  if (error)
  {
    /*
      Note that we depend on that str_arg is null terminated, which is true
      when we are in the parser
    */
    DBUG_ASSERT(str_arg[length] == 0);
4814
    my_error(ER_ILLEGAL_VALUE_FOR_TYPE, MYF(0), "double", (char*) str_arg);
4815 4816
  }
  presentation= name=(char*) str_arg;
4817
  decimals=(uint8) nr_of_decimals(str_arg, str_arg+length);
4818 4819 4820 4821 4822
  max_length=length;
  fixed= 1;
}


4823
int Item_float::save_in_field(Field *field, bool no_conversions)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4824
{
4825
  double nr= val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4826 4827 4828
  if (null_value)
    return set_field_to_null(field);
  field->set_notnull();
4829
  return field->store(nr);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4830 4831
}

4832

4833
void Item_float::print(String *str, enum_query_type query_type)
4834 4835 4836 4837 4838 4839 4840 4841
{
  if (presentation)
  {
    str->append(presentation);
    return;
  }
  char buffer[20];
  String num(buffer, sizeof(buffer), &my_charset_bin);
4842
  num.set_real(value, decimals, &my_charset_bin);
4843 4844 4845 4846
  str->append(num);
}


ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
4847 4848 4849 4850 4851
/*
  hex item
  In string context this is a binary string.
  In number context this is a longlong value.
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4852

4853
bool Item_float::eq(const Item *arg, bool binary_cmp) const
4854 4855 4856 4857 4858 4859 4860 4861
{
  if (arg->basic_const_item() && arg->type() == type())
  {
    /*
      We need to cast off const to call val_int(). This should be OK for
      a basic constant.
    */
    Item *item= (Item*) arg;
4862
    return item->val_real() == value;
4863 4864 4865 4866
  }
  return FALSE;
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
4867

4868
inline uint char_val(char X)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4869 4870 4871 4872 4873 4874
{
  return (uint) (X >= '0' && X <= '9' ? X-'0' :
		 X >= 'A' && X <= 'Z' ? X-'A'+10 :
		 X-'a'+10);
}

4875

ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
4876
Item_hex_string::Item_hex_string(const char *str, uint str_length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4877 4878 4879 4880 4881
{
  max_length=(str_length+1)/2;
  char *ptr=(char*) sql_alloc(max_length+1);
  if (!ptr)
    return;
4882
  str_value.set(ptr,max_length,&my_charset_bin);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4883 4884 4885 4886 4887 4888 4889 4890 4891
  char *end=ptr+max_length;
  if (max_length*2 != str_length)
    *ptr++=char_val(*str++);			// Not even, assume 0 prefix
  while (ptr != end)
  {
    *ptr++= (char) (char_val(str[0])*16+char_val(str[1]));
    str+=2;
  }
  *ptr=0;					// Keep purify happy
4892
  collation.set(&my_charset_bin, DERIVATION_COERCIBLE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4893
  fixed= 1;
4894
  unsigned_flag= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4895 4896
}

ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
4897
longlong Item_hex_string::val_int()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4898
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
4899
  // following assert is redundant, because fixed=1 assigned in constructor
4900
  DBUG_ASSERT(fixed == 1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4901 4902 4903 4904 4905 4906 4907 4908 4909 4910
  char *end=(char*) str_value.ptr()+str_value.length(),
       *ptr=end-min(str_value.length(),sizeof(longlong));

  ulonglong value=0;
  for (; ptr != end ; ptr++)
    value=(value << 8)+ (ulonglong) (uchar) *ptr;
  return (longlong) value;
}


4911 4912 4913 4914 4915 4916 4917 4918 4919 4920
my_decimal *Item_hex_string::val_decimal(my_decimal *decimal_value)
{
  // following assert is redundant, because fixed=1 assigned in constructor
  DBUG_ASSERT(fixed == 1);
  ulonglong value= (ulonglong)val_int();
  int2my_decimal(E_DEC_FATAL_ERROR, value, TRUE, decimal_value);
  return (decimal_value);
}


ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
4921
int Item_hex_string::save_in_field(Field *field, bool no_conversions)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4922 4923 4924
{
  field->set_notnull();
  if (field->result_type() == STRING_RESULT)
4925 4926 4927 4928 4929 4930
    return field->store(str_value.ptr(), str_value.length(), 
                        collation.collation);

  ulonglong nr;
  uint32 length= str_value.length();
  if (length > 8)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4931
  {
4932 4933
    nr= field->flags & UNSIGNED_FLAG ? ULONGLONG_MAX : LONGLONG_MAX;
    goto warn;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4934
  }
4935 4936
  nr= (ulonglong) val_int();
  if ((length == 8) && !(field->flags & UNSIGNED_FLAG) && (nr > LONGLONG_MAX))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4937
  {
4938 4939
    nr= LONGLONG_MAX;
    goto warn;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4940
  }
4941
  return field->store((longlong) nr, TRUE);  // Assume hex numbers are unsigned
4942 4943

warn:
4944
  if (!field->store((longlong) nr, TRUE))
4945 4946 4947
    field->set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE,
                       1);
  return 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
4948 4949 4950
}


4951
void Item_hex_string::print(String *str, enum_query_type query_type)
4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963
{
  char *end= (char*) str_value.ptr() + str_value.length(),
       *ptr= end - min(str_value.length(), sizeof(longlong));
  str->append("0x");
  for (; ptr != end ; ptr++)
  {
    str->append(_dig_vec_lower[((uchar) *ptr) >> 4]);
    str->append(_dig_vec_lower[((uchar) *ptr) & 0x0F]);
  }
}


4964
bool Item_hex_string::eq(const Item *arg, bool binary_cmp) const
4965 4966 4967 4968 4969 4970 4971 4972 4973 4974
{
  if (arg->basic_const_item() && arg->type() == type())
  {
    if (binary_cmp)
      return !stringcmp(&str_value, &arg->str_value);
    return !sortcmp(&str_value, &arg->str_value, collation.collation);
  }
  return FALSE;
}

bar@mysql.com's avatar
bar@mysql.com committed
4975

bar@mysql.com's avatar
bar@mysql.com committed
4976
Item *Item_hex_string::safe_charset_converter(CHARSET_INFO *tocs)
bar@mysql.com's avatar
bar@mysql.com committed
4977 4978 4979 4980 4981 4982 4983
{
  Item_string *conv;
  String tmp, *str= val_str(&tmp);

  if (!(conv= new Item_string(str->ptr(), str->length(), tocs)))
    return NULL;
  conv->str_value.copy();
4984
  conv->str_value.mark_as_const();
bar@mysql.com's avatar
bar@mysql.com committed
4985 4986 4987 4988
  return conv;
}


ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025
/*
  bin item.
  In string context this is a binary string.
  In number context this is a longlong value.
*/
  
Item_bin_string::Item_bin_string(const char *str, uint str_length)
{
  const char *end= str + str_length - 1;
  uchar bits= 0;
  uint power= 1;

  max_length= (str_length + 7) >> 3;
  char *ptr= (char*) sql_alloc(max_length + 1);
  if (!ptr)
    return;
  str_value.set(ptr, max_length, &my_charset_bin);
  ptr+= max_length - 1;
  ptr[1]= 0;                     // Set end null for string
  for (; end >= str; end--)
  {
    if (power == 256)
    {
      power= 1;
      *ptr--= bits;
      bits= 0;     
    }
    if (*end == '1')
      bits|= power; 
    power<<= 1;
  }
  *ptr= (char) bits;
  collation.set(&my_charset_bin, DERIVATION_COERCIBLE);
  fixed= 1;
}


5026 5027
/**
  Pack data in buffer for sending.
5028 5029 5030
*/

bool Item_null::send(Protocol *protocol, String *packet)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5031
{
5032
  return protocol->store_null();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5033 5034
}

5035 5036
/**
  This is only called from items that is not of type item_field.
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5037 5038
*/

5039
bool Item::send(Protocol *protocol, String *buffer)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5040
{
5041
  bool result;
5042
  enum_field_types f_type;
5043
  LINT_INIT(result);                     // Will be set if null_value == 0
5044

5045
  switch ((f_type=field_type())) {
5046
  default:
5047 5048 5049 5050 5051 5052 5053 5054 5055
  case MYSQL_TYPE_NULL:
  case MYSQL_TYPE_DECIMAL:
  case MYSQL_TYPE_ENUM:
  case MYSQL_TYPE_SET:
  case MYSQL_TYPE_TINY_BLOB:
  case MYSQL_TYPE_MEDIUM_BLOB:
  case MYSQL_TYPE_LONG_BLOB:
  case MYSQL_TYPE_BLOB:
  case MYSQL_TYPE_GEOMETRY:
5056 5057
  case MYSQL_TYPE_STRING:
  case MYSQL_TYPE_VAR_STRING:
5058
  case MYSQL_TYPE_VARCHAR:
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
5059
  case MYSQL_TYPE_BIT:
5060
  case MYSQL_TYPE_NEWDECIMAL:
5061 5062 5063
  {
    String *res;
    if ((res=val_str(buffer)))
5064
      result= protocol->store(res->ptr(),res->length(),res->charset());
5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075
    break;
  }
  case MYSQL_TYPE_TINY:
  {
    longlong nr;
    nr= val_int();
    if (!null_value)
      result= protocol->store_tiny(nr);
    break;
  }
  case MYSQL_TYPE_SHORT:
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
5076
  case MYSQL_TYPE_YEAR:
5077 5078 5079 5080 5081 5082 5083
  {
    longlong nr;
    nr= val_int();
    if (!null_value)
      result= protocol->store_short(nr);
    break;
  }
5084
  case MYSQL_TYPE_INT24:
5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100
  case MYSQL_TYPE_LONG:
  {
    longlong nr;
    nr= val_int();
    if (!null_value)
      result= protocol->store_long(nr);
    break;
  }
  case MYSQL_TYPE_LONGLONG:
  {
    longlong nr;
    nr= val_int();
    if (!null_value)
      result= protocol->store_longlong(nr, unsigned_flag);
    break;
  }
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
5101 5102 5103
  case MYSQL_TYPE_FLOAT:
  {
    float nr;
5104
    nr= (float) val_real();
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
5105 5106 5107 5108
    if (!null_value)
      result= protocol->store(nr, decimals, buffer);
    break;
  }
5109 5110
  case MYSQL_TYPE_DOUBLE:
  {
5111
    double nr= val_real();
5112 5113 5114 5115 5116 5117
    if (!null_value)
      result= protocol->store(nr, decimals, buffer);
    break;
  }
  case MYSQL_TYPE_DATETIME:
  case MYSQL_TYPE_DATE:
5118
  case MYSQL_TYPE_TIMESTAMP:
5119
  {
5120
    MYSQL_TIME tm;
5121
    get_date(&tm, TIME_FUZZY_DATE);
5122 5123
    if (!null_value)
    {
5124
      if (f_type == MYSQL_TYPE_DATE)
5125 5126 5127 5128 5129 5130 5131 5132
	return protocol->store_date(&tm);
      else
	result= protocol->store(&tm);
    }
    break;
  }
  case MYSQL_TYPE_TIME:
  {
5133
    MYSQL_TIME tm;
5134 5135 5136 5137 5138 5139 5140 5141 5142
    get_time(&tm);
    if (!null_value)
      result= protocol->store_time(&tm);
    break;
  }
  }
  if (null_value)
    result= protocol->store_null();
  return result;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5143 5144
}

5145 5146

bool Item_field::send(Protocol *protocol, String *buffer)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5147
{
5148
  return protocol->store(result_field);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5149 5150
}

5151

5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167
void Item_field::update_null_value() 
{ 
  /* 
    need to set no_errors to prevent warnings about type conversion 
    popping up.
  */
  THD *thd= field->table->in_use;
  int no_errors;

  no_errors= thd->no_errors;
  thd->no_errors= 1;
  Item::update_null_value();
  thd->no_errors= no_errors;
}


5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189
/*
  Add the field to the select list and substitute it for the reference to
  the field.

  SYNOPSIS
    Item_field::update_value_transformer()
    select_arg      current select

  DESCRIPTION
    If the field doesn't belong to the table being inserted into then it is
    added to the select list, pointer to it is stored in the ref_pointer_array
    of the select and the field itself is substituted for the Item_ref object.
    This is done in order to get correct values from update fields that
    belongs to the SELECT part in the INSERT .. SELECT .. ON DUPLICATE KEY
    UPDATE statement.

  RETURN
    0             if error occured
    ref           if all conditions are met
    this field    otherwise
*/

5190
Item *Item_field::update_value_transformer(uchar *select_arg)
5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212
{
  SELECT_LEX *select= (SELECT_LEX*)select_arg;
  DBUG_ASSERT(fixed);

  if (field->table != select->context.table_list->table &&
      type() != Item::TRIGGER_FIELD_ITEM)
  {
    List<Item> *all_fields= &select->join->all_fields;
    Item **ref_pointer_array= select->ref_pointer_array;
    int el= all_fields->elements;
    Item_ref *ref;

    ref_pointer_array[el]= (Item*)this;
    all_fields->push_front((Item*)this);
    ref= new Item_ref(&select->context, ref_pointer_array + el,
                      table_name, field_name);
    return ref;
  }
  return this;
}


5213
void Item_field::print(String *str, enum_query_type query_type)
5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224
{
  if (field && field->table->const_table)
  {
    char buff[MAX_FIELD_WIDTH];
    String tmp(buff,sizeof(buff),str->charset());
    field->val_str(&tmp);
    str->append('\'');
    str->append(tmp);
    str->append('\'');
    return;
  }
5225
  Item_ident::print(str, query_type);
5226 5227 5228
}


5229 5230
Item_ref::Item_ref(Name_resolution_context *context_arg,
                   Item **item, const char *table_name_arg,
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
5231 5232
                   const char *field_name_arg,
                   bool alias_name_used_arg)
5233 5234
  :Item_ident(context_arg, NullS, table_name_arg, field_name_arg),
   result_field(0), ref(item)
5235
{
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
5236
  alias_name_used= alias_name_used_arg;
5237 5238 5239
  /*
    This constructor used to create some internals references over fixed items
  */
5240
  if (ref && *ref && (*ref)->fixed)
5241 5242 5243 5244
    set_properties();
}


5245
/**
5246
  Resolve the name of a reference to a column reference.
5247

5248 5249 5250 5251
  The method resolves the column reference represented by 'this' as a column
  present in one of: GROUP BY clause, SELECT clause, outer queries. It is
  used typically for columns in the HAVING clause which are not under
  aggregate functions.
5252

5253 5254
  POSTCONDITION @n
  Item_ref::ref is 0 or points to a valid item.
5255

5256
  @note
5257 5258
    The name resolution algorithm used is (where [T_j] is an optional table
    name that qualifies the column name):
5259

5260 5261
  @code
        resolve_extended([T_j].col_ref_i)
5262
        {
5263 5264
          Search for a column or derived column named col_ref_i [in table T_j]
          in the SELECT and GROUP clauses of Q.
5265

5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282
          if such a column is NOT found AND    // Lookup in outer queries.
             there are outer queries
          {
            for each outer query Q_k beginning from the inner-most one
           {
              Search for a column or derived column named col_ref_i
              [in table T_j] in the SELECT and GROUP clauses of Q_k.

              if such a column is not found AND
                 - Q_k is not a group query AND
                 - Q_k is not inside an aggregate function
                 OR
                 - Q_(k-1) is not in a HAVING or SELECT clause of Q_k
              {
                search for a column or derived column named col_ref_i
                [in table T_j] in the FROM clause of Q_k;
              }
5283 5284 5285
            }
          }
        }
5286 5287
  @endcode
  @n
5288
    This procedure treats GROUP BY and SELECT clauses as one namespace for
5289 5290 5291
    column references in HAVING. Notice that compared to
    Item_field::fix_fields, here we first search the SELECT and GROUP BY
    clauses, and then we search the FROM clause.
5292

5293 5294 5295
  @param[in]     thd        current thread
  @param[in,out] reference  view column if this item was resolved to a
    view column
5296

5297 5298 5299 5300 5301 5302 5303
  @todo
    Here we could first find the field anyway, and then test this
    condition, so that we can give a better error message -
    ER_WRONG_FIELD_WITH_GROUP, instead of the less informative
    ER_BAD_FIELD_ERROR which we produce now.

  @retval
5304
    TRUE  if error
5305
  @retval
5306 5307
    FALSE on success
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5308

5309
bool Item_ref::fix_fields(THD *thd, Item **reference)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5310
{
5311
  enum_parsing_place place= NO_MATTER;
5312
  DBUG_ASSERT(fixed == 0);
5313 5314
  SELECT_LEX *current_sel= thd->lex->current_select;

5315
  if (!ref || ref == not_found_item)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5316
  {
5317 5318 5319
    if (!(ref= resolve_ref_in_select_and_group(thd, this,
                                               context->select_lex)))
      goto error;             /* Some error occurred (e.g. ambiguous names). */
5320

5321
    if (ref == not_found_item) /* This reference was not resolved. */
5322
    {
5323 5324
      Name_resolution_context *last_checked_context= context;
      Name_resolution_context *outer_context= context->outer_context;
5325 5326 5327
      Field *from_field;
      ref= 0;

5328
      if (!outer_context)
5329 5330 5331 5332
      {
        /* The current reference cannot be resolved in this query. */
        my_error(ER_BAD_FIELD_ERROR,MYF(0),
                 this->full_name(), current_thd->where);
5333
        goto error;
5334
      }
5335

5336
      /*
5337 5338 5339
        If there is an outer context (select), and it is not a derived table
        (which do not support the use of outer fields for now), try to
        resolve this reference in the outer select(s).
5340

5341 5342 5343
        We treat each subselect as a separate namespace, so that different
        subselects may contain columns with the same names. The subselects are
        searched starting from the innermost.
5344
      */
5345 5346
      from_field= (Field*) not_found_field;

5347
      do
5348
      {
5349 5350 5351 5352
        SELECT_LEX *select= outer_context->select_lex;
        Item_subselect *prev_subselect_item=
          last_checked_context->select_lex->master_unit()->item;
        last_checked_context= outer_context;
5353

5354
        /* Search in the SELECT and GROUP lists of the outer select. */
5355
        if (outer_context->resolve_in_select_list)
5356
        {
5357 5358
          if (!(ref= resolve_ref_in_select_and_group(thd, this, select)))
            goto error; /* Some error occurred (e.g. ambiguous names). */
5359
          if (ref != not_found_item)
5360
          {
5361 5362 5363 5364
            DBUG_ASSERT(*ref && (*ref)->fixed);
            prev_subselect_item->used_tables_cache|= (*ref)->used_tables();
            prev_subselect_item->const_item_cache&= (*ref)->const_item();
            break;
5365 5366
          }
          /*
5367 5368 5369
            Set ref to 0 to ensure that we get an error in case we replaced
            this item with another item and still use this item in some
            other place of the parse tree.
5370
          */
5371
          ref= 0;
5372
        }
5373

5374 5375 5376 5377 5378
        place= prev_subselect_item->parsing_place;
        /*
          Check table fields only if the subquery is used somewhere out of
          HAVING or the outer SELECT does not use grouping (i.e. tables are
          accessible).
5379
          TODO:
5380 5381 5382 5383 5384 5385
          Here we could first find the field anyway, and then test this
          condition, so that we can give a better error message -
          ER_WRONG_FIELD_WITH_GROUP, instead of the less informative
          ER_BAD_FIELD_ERROR which we produce now.
        */
        if ((place != IN_HAVING ||
5386 5387
             (!select->with_sum_func &&
              select->group_list.elements == 0)))
5388
        {
5389
          /*
5390 5391 5392
            In case of view, find_field_in_tables() write pointer to view
            field expression to 'reference', i.e. it substitute that
            expression instead of this Item_ref
5393
          */
5394
          from_field= find_field_in_tables(thd, this,
5395 5396 5397 5398
                                           outer_context->
                                             first_name_resolution_table,
                                           outer_context->
                                             last_name_resolution_table,
5399 5400
                                           reference,
                                           IGNORE_EXCEPT_NON_UNIQUE,
5401
                                           TRUE, TRUE);
5402
          if (! from_field)
5403
            goto error;
5404
          if (from_field == view_ref_found)
5405
          {
5406
            Item::Type refer_type= (*reference)->type();
5407 5408 5409 5410 5411
            prev_subselect_item->used_tables_cache|=
              (*reference)->used_tables();
            prev_subselect_item->const_item_cache&=
              (*reference)->const_item();
            DBUG_ASSERT((*reference)->type() == REF_ITEM);
5412 5413
            mark_as_dependent(thd, last_checked_context->select_lex,
                              context->select_lex, this,
5414 5415
                              ((refer_type == REF_ITEM ||
                                refer_type == FIELD_ITEM) ?
5416 5417 5418 5419 5420 5421
                               (Item_ident*) (*reference) :
                               0));
            /*
              view reference found, we substituted it instead of this
              Item, so can quit
            */
5422 5423
            return FALSE;
          }
5424 5425
          if (from_field != not_found_field)
          {
5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444
            if (cached_table && cached_table->select_lex &&
                outer_context->select_lex &&
                cached_table->select_lex != outer_context->select_lex)
            {
              /*
                Due to cache, find_field_in_tables() can return field which
                doesn't belong to provided outer_context. In this case we have
                to find proper field context in order to fix field correcly.
              */
              do
              {
                outer_context= outer_context->outer_context;
                select= outer_context->select_lex;
                prev_subselect_item=
                  last_checked_context->select_lex->master_unit()->item;
                last_checked_context= outer_context;
              } while (outer_context && outer_context->select_lex &&
                       cached_table->select_lex != outer_context->select_lex);
            }
5445 5446 5447 5448
            prev_subselect_item->used_tables_cache|= from_field->table->map;
            prev_subselect_item->const_item_cache= 0;
            break;
          }
5449
        }
5450 5451 5452 5453 5454 5455
        DBUG_ASSERT(from_field == not_found_field);

        /* Reference is not found => depend on outer (or just error). */
        prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
        prev_subselect_item->const_item_cache= 0;

5456 5457
        outer_context= outer_context->outer_context;
      } while (outer_context);
5458 5459 5460

      DBUG_ASSERT(from_field != 0 && from_field != view_ref_found);
      if (from_field != not_found_field)
5461
      {
5462 5463
        Item_field* fld;
        if (!(fld= new Item_field(from_field)))
5464
          goto error;
5465
        thd->change_item_tree(reference, fld);
5466 5467
        mark_as_dependent(thd, last_checked_context->select_lex,
                          thd->lex->current_select, this, fld);
gkodinov/kgeorge@magare.gmz's avatar
gkodinov/kgeorge@magare.gmz committed
5468 5469 5470 5471 5472 5473 5474 5475 5476 5477
        /*
          A reference is resolved to a nest level that's outer or the same as
          the nest level of the enclosing set function : adjust the value of
          max_arg_level for the function if it's needed.
        */
        if (thd->lex->in_sum_func &&
            thd->lex->in_sum_func->nest_level >= 
            last_checked_context->select_lex->nest_level)
          set_if_bigger(thd->lex->in_sum_func->max_arg_level,
                        last_checked_context->select_lex->nest_level);
5478 5479 5480 5481 5482 5483
        return FALSE;
      }
      if (ref == 0)
      {
        /* The item was not a table field and not a reference */
        my_error(ER_BAD_FIELD_ERROR, MYF(0),
5484
                 this->full_name(), current_thd->where);
5485
        goto error;
5486
      }
5487 5488
      /* Should be checked in resolve_ref_in_select_and_group(). */
      DBUG_ASSERT(*ref && (*ref)->fixed);
5489 5490
      mark_as_dependent(thd, last_checked_context->select_lex,
                        context->select_lex, this, this);
gkodinov/kgeorge@magare.gmz's avatar
gkodinov/kgeorge@magare.gmz committed
5491 5492 5493 5494 5495 5496 5497 5498 5499 5500
      /*
        A reference is resolved to a nest level that's outer or the same as
        the nest level of the enclosing set function : adjust the value of
        max_arg_level for the function if it's needed.
      */
      if (thd->lex->in_sum_func &&
          thd->lex->in_sum_func->nest_level >= 
          last_checked_context->select_lex->nest_level)
        set_if_bigger(thd->lex->in_sum_func->max_arg_level,
                      last_checked_context->select_lex->nest_level);
5501
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5502
  }
5503

5504
  DBUG_ASSERT(*ref);
5505
  /*
5506 5507 5508
    Check if this is an incorrect reference in a group function or forward
    reference. Do not issue an error if this is an unnamed reference inside an
    aggregate function.
5509
  */
5510
  if (((*ref)->with_sum_func && name &&
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5511 5512
       !(current_sel->linkage != GLOBAL_OPTIONS_TYPE &&
         current_sel->having_fix_field)) ||
5513 5514
      !(*ref)->fixed)
  {
5515 5516 5517 5518
    my_error(ER_ILLEGAL_REFERENCE, MYF(0),
             name, ((*ref)->with_sum_func?
                    "reference to group function":
                    "forward reference in item list"));
5519
    goto error;
5520
  }
5521 5522 5523

  set_properties();

5524
  if ((*ref)->check_cols(1))
5525
    goto error;
5526
  return FALSE;
5527 5528 5529 5530

error:
  context->process_error(thd);
  return TRUE;
5531 5532
}

5533

5534 5535
void Item_ref::set_properties()
{
5536 5537 5538
  max_length= (*ref)->max_length;
  maybe_null= (*ref)->maybe_null;
  decimals=   (*ref)->decimals;
5539
  collation.set((*ref)->collation);
monty@mysql.com's avatar
monty@mysql.com committed
5540 5541 5542 5543
  /*
    We have to remember if we refer to a sum function, to ensure that
    split_sum_func() doesn't try to change the reference.
  */
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
5544
  with_sum_func= (*ref)->with_sum_func;
timour@mysql.com's avatar
Merge  
timour@mysql.com committed
5545
  unsigned_flag= (*ref)->unsigned_flag;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
5546 5547 5548
  fixed= 1;
  if (alias_name_used)
    return;
5549 5550 5551 5552
  if ((*ref)->type() == FIELD_ITEM)
    alias_name_used= ((Item_ident *) (*ref))->alias_name_used;
  else
    alias_name_used= TRUE; // it is not field, so it is was resolved by alias
bk@work.mysql.com's avatar
bk@work.mysql.com committed
5553 5554
}

5555

hf@deer.(none)'s avatar
hf@deer.(none) committed
5556 5557
void Item_ref::cleanup()
{
5558
  DBUG_ENTER("Item_ref::cleanup");
hf@deer.(none)'s avatar
hf@deer.(none) committed
5559
  Item_ident::cleanup();
5560
  result_field= 0;
5561
  DBUG_VOID_RETURN;
hf@deer.(none)'s avatar
hf@deer.(none) committed
5562 5563 5564
}


5565
void Item_ref::print(String *str, enum_query_type query_type)
5566
{
5567
  if (ref)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5568 5569
  {
    if ((*ref)->type() != Item::CACHE_ITEM && ref_type() != VIEW_REF &&
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
5570
        !table_name && name && alias_name_used)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5571 5572 5573 5574 5575
    {
      THD *thd= current_thd;
      append_identifier(thd, str, name, (uint) strlen(name));
    }
    else
5576
      (*ref)->print(str, query_type);
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5577
  }
5578
  else
5579
    Item_ident::print(str, query_type);
5580 5581 5582
}


5583 5584 5585 5586 5587 5588 5589 5590
bool Item_ref::send(Protocol *prot, String *tmp)
{
  if (result_field)
    return prot->store(result_field);
  return (*ref)->send(prot, tmp);
}


5591 5592 5593 5594 5595 5596 5597 5598
double Item_ref::val_result()
{
  if (result_field)
  {
    if ((null_value= result_field->is_null()))
      return 0.0;
    return result_field->val_real();
  }
5599
  return val_real();
5600 5601 5602 5603 5604 5605 5606 5607
}


longlong Item_ref::val_int_result()
{
  if (result_field)
  {
    if ((null_value= result_field->is_null()))
5608
      return 0;
5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627
    return result_field->val_int();
  }
  return val_int();
}


String *Item_ref::str_result(String* str)
{
  if (result_field)
  {
    if ((null_value= result_field->is_null()))
      return 0;
    str->set_charset(str_value.charset());
    return result_field->val_str(str, &str_value);
  }
  return val_str(str);
}


5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645
my_decimal *Item_ref::val_decimal_result(my_decimal *decimal_value)
{
  if (result_field)
  {
    if ((null_value= result_field->is_null()))
      return 0;
    return result_field->val_decimal(decimal_value);
  }
  return val_decimal(decimal_value);
}


bool Item_ref::val_bool_result()
{
  if (result_field)
  {
    if ((null_value= result_field->is_null()))
      return 0;
5646
    switch (result_field->result_type()) {
5647
    case INT_RESULT:
5648
      return result_field->val_int() != 0;
5649
    case DECIMAL_RESULT:
5650 5651 5652 5653 5654 5655 5656
    {
      my_decimal decimal_value;
      my_decimal *val= result_field->val_decimal(&decimal_value);
      if (val)
        return !my_decimal_is_zero(val);
      return 0;
    }
5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707
    case REAL_RESULT:
    case STRING_RESULT:
      return result_field->val_real() != 0.0;
    case ROW_RESULT:
    default:
      DBUG_ASSERT(0);
    }
  }
  return val_bool();
}


double Item_ref::val_real()
{
  DBUG_ASSERT(fixed);
  double tmp=(*ref)->val_result();
  null_value=(*ref)->null_value;
  return tmp;
}


longlong Item_ref::val_int()
{
  DBUG_ASSERT(fixed);
  longlong tmp=(*ref)->val_int_result();
  null_value=(*ref)->null_value;
  return tmp;
}


bool Item_ref::val_bool()
{
  DBUG_ASSERT(fixed);
  bool tmp= (*ref)->val_bool_result();
  null_value= (*ref)->null_value;
  return tmp;
}


String *Item_ref::val_str(String* tmp)
{
  DBUG_ASSERT(fixed);
  tmp=(*ref)->str_result(tmp);
  null_value=(*ref)->null_value;
  return tmp;
}


bool Item_ref::is_null()
{
  DBUG_ASSERT(fixed);
5708
  return (*ref)->is_null();
5709 5710 5711
}


5712
bool Item_ref::get_date(MYSQL_TIME *ltime,uint fuzzydate)
5713 5714 5715 5716 5717 5718 5719
{
  return (null_value=(*ref)->get_date_result(ltime,fuzzydate));
}


my_decimal *Item_ref::val_decimal(my_decimal *decimal_value)
{
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
5720
  my_decimal *val= (*ref)->val_decimal_result(decimal_value);
5721 5722 5723 5724
  null_value= (*ref)->null_value;
  return val;
}

5725 5726 5727
int Item_ref::save_in_field(Field *to, bool no_conversions)
{
  int res;
5728
  DBUG_ASSERT(!result_field);
5729 5730 5731 5732 5733
  res= (*ref)->save_in_field(to, no_conversions);
  null_value= (*ref)->null_value;
  return res;
}

5734

5735 5736 5737 5738 5739 5740
void Item_ref::save_org_in_field(Field *field)
{
  (*ref)->save_org_in_field(field);
}


5741 5742 5743 5744 5745 5746 5747 5748 5749 5750
void Item_ref::make_field(Send_field *field)
{
  (*ref)->make_field(field);
  /* Non-zero in case of a view */
  if (name)
    field->col_name= name;
  if (table_name)
    field->table_name= table_name;
  if (db_name)
    field->db_name= db_name;
5751
}
5752 5753


gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768
Item *Item_ref::get_tmp_table_item(THD *thd)
{
  if (!result_field)
    return (*ref)->get_tmp_table_item(thd);

  Item_field *item= new Item_field(result_field);
  if (item)
  {
    item->table_name= table_name;
    item->db_name= db_name;
  }
  return item;
}


5769
void Item_ref_null_helper::print(String *str, enum_query_type query_type)
5770
{
5771
  str->append(STRING_WITH_LEN("<ref_null_helper>("));
5772
  if (ref)
5773
    (*ref)->print(str, query_type);
5774 5775 5776 5777 5778 5779
  else
    str->append('?');
  str->append(')');
}


5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821
double Item_direct_ref::val_real()
{
  double tmp=(*ref)->val_real();
  null_value=(*ref)->null_value;
  return tmp;
}


longlong Item_direct_ref::val_int()
{
  longlong tmp=(*ref)->val_int();
  null_value=(*ref)->null_value;
  return tmp;
}


String *Item_direct_ref::val_str(String* tmp)
{
  tmp=(*ref)->val_str(tmp);
  null_value=(*ref)->null_value;
  return tmp;
}


my_decimal *Item_direct_ref::val_decimal(my_decimal *decimal_value)
{
  my_decimal *tmp= (*ref)->val_decimal(decimal_value);
  null_value=(*ref)->null_value;
  return tmp;
}


bool Item_direct_ref::val_bool()
{
  bool tmp= (*ref)->val_bool();
  null_value=(*ref)->null_value;
  return tmp;
}


bool Item_direct_ref::is_null()
{
monty@mysql.com's avatar
monty@mysql.com committed
5822
  return (*ref)->is_null();
5823 5824 5825
}


5826
bool Item_direct_ref::get_date(MYSQL_TIME *ltime,uint fuzzydate)
5827 5828 5829 5830 5831
{
  return (null_value=(*ref)->get_date(ltime,fuzzydate));
}


5832 5833
/**
  Prepare referenced field then call usual Item_direct_ref::fix_fields .
5834

5835 5836
  @param thd         thread handler
  @param reference   reference on reference where this item stored
5837

5838
  @retval
5839
    FALSE   OK
5840
  @retval
5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854
    TRUE    Error
*/

bool Item_direct_view_ref::fix_fields(THD *thd, Item **reference)
{
  /* view fild reference must be defined */
  DBUG_ASSERT(*ref);
  /* (*ref)->check_cols() will be made in Item_direct_ref::fix_fields */
  if (!(*ref)->fixed &&
      ((*ref)->fix_fields(thd, ref)))
    return TRUE;
  return Item_direct_ref::fix_fields(thd, reference);
}

5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869
/*
  Prepare referenced outer field then call usual Item_direct_ref::fix_fields

  SYNOPSIS
    Item_outer_ref::fix_fields()
    thd         thread handler
    reference   reference on reference where this item stored

  RETURN
    FALSE   OK
    TRUE    Error
*/

bool Item_outer_ref::fix_fields(THD *thd, Item **reference)
{
5870 5871 5872
  bool err;
  /* outer_ref->check_cols() will be made in Item_direct_ref::fix_fields */
  if ((*ref) && !(*ref)->fixed && ((*ref)->fix_fields(thd, reference)))
5873
    return TRUE;
5874 5875 5876 5877 5878 5879
  err= Item_direct_ref::fix_fields(thd, reference);
  if (!outer_ref)
    outer_ref= *ref;
  if ((*ref)->type() == Item::FIELD_ITEM)
    table_name= ((Item_field*)outer_ref)->table_name;
  return err;
5880 5881
}

5882

5883
/**
5884
  Compare two view column references for equality.
5885

5886 5887 5888 5889
  A view column reference is considered equal to another column
  reference if the second one is a view column and if both column
  references resolve to the same item. It is assumed that both
  items are of the same type.
5890

5891 5892
  @param item        item to compare with
  @param binary_cmp  make binary comparison
5893

5894
  @retval
5895
    TRUE    Referenced item is equal to given item
5896
  @retval
5897 5898 5899 5900 5901
    FALSE   otherwise
*/

bool Item_direct_view_ref::eq(const Item *item, bool binary_cmp) const
{
5902 5903 5904 5905 5906 5907
  if (item->type() == REF_ITEM)
  {
    Item_ref *item_ref= (Item_ref*) item;
    if (item_ref->ref_type() == VIEW_REF)
    {
      Item *item_ref_ref= *(item_ref->ref);
5908
      return ((*ref)->real_item() == item_ref_ref->real_item());
5909 5910 5911
    }
  }
  return FALSE;
5912
}
5913

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5914 5915
bool Item_default_value::eq(const Item *item, bool binary_cmp) const
{
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5916
  return item->type() == DEFAULT_VALUE_ITEM && 
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5917 5918 5919
    ((Item_default_value *)item)->arg->eq(arg, binary_cmp);
}

5920

5921
bool Item_default_value::fix_fields(THD *thd, Item **items)
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5922
{
5923
  Item *real_arg;
5924 5925
  Item_field *field_arg;
  Field *def_field;
5926
  DBUG_ASSERT(fixed == 0);
5927

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5928
  if (!arg)
5929 5930
  {
    fixed= 1;
5931
    return FALSE;
5932
  }
5933 5934 5935
  if (!arg->fixed && arg->fix_fields(thd, &arg))
    goto error;

5936

5937 5938
  real_arg= arg->real_item();
  if (real_arg->type() != FIELD_ITEM)
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5939
  {
5940
    my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0), arg->name);
5941
    goto error;
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5942
  }
5943

5944
  field_arg= (Item_field *)real_arg;
5945 5946
  if (field_arg->field->flags & NO_DEFAULT_VALUE_FLAG)
  {
5947
    my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0), field_arg->field->field_name);
5948
    goto error;
5949 5950
  }
  if (!(def_field= (Field*) sql_alloc(field_arg->field->size_of())))
5951
    goto error;
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5952
  memcpy(def_field, field_arg->field, field_arg->field->size_of());
5953 5954 5955
  def_field->move_field_offset((my_ptrdiff_t)
                               (def_field->table->s->default_values -
                                def_field->table->record[0]));
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5956
  set_field(def_field);
5957
  return FALSE;
5958 5959 5960 5961

error:
  context->process_error(thd);
  return TRUE;
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5962 5963
}

5964

5965
void Item_default_value::print(String *str, enum_query_type query_type)
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5966
{
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5967 5968
  if (!arg)
  {
5969
    str->append(STRING_WITH_LEN("default"));
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5970
    return;
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5971
  }
5972
  str->append(STRING_WITH_LEN("default("));
5973
  arg->print(str, query_type);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
5974 5975
  str->append(')');
}
5976

5977 5978 5979 5980 5981 5982 5983

int Item_default_value::save_in_field(Field *field_arg, bool no_conversions)
{
  if (!arg)
  {
    if (field_arg->flags & NO_DEFAULT_VALUE_FLAG)
    {
5984 5985 5986 5987 5988 5989 5990
      if (field_arg->reset())
      {
        my_message(ER_CANT_CREATE_GEOMETRY_OBJECT,
                   ER(ER_CANT_CREATE_GEOMETRY_OBJECT), MYF(0));
        return -1;
      }

5991 5992
      if (context->error_processor == &view_error_processor)
      {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
5993
        TABLE_LIST *view= cached_table->top_table();
5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008
        push_warning_printf(field_arg->table->in_use,
                            MYSQL_ERROR::WARN_LEVEL_WARN,
                            ER_NO_DEFAULT_FOR_VIEW_FIELD,
                            ER(ER_NO_DEFAULT_FOR_VIEW_FIELD),
                            view->view_db.str,
                            view->view_name.str);
      }
      else
      {
        push_warning_printf(field_arg->table->in_use,
                            MYSQL_ERROR::WARN_LEVEL_WARN,
                            ER_NO_DEFAULT_FOR_FIELD,
                            ER(ER_NO_DEFAULT_FOR_FIELD),
                            field_arg->field_name);
      }
6009 6010 6011 6012 6013 6014 6015 6016 6017
      return 1;
    }
    field_arg->set_default();
    return 0;
  }
  return Item_field::save_in_field(field_arg, no_conversions);
}


6018
/**
6019
  This method like the walk method traverses the item tree, but at the
6020
  same time it can replace some nodes in the tree.
6021
*/ 
6022

6023
Item *Item_default_value::transform(Item_transformer transformer, uchar *args)
6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042
{
  DBUG_ASSERT(!current_thd->is_stmt_prepare());

  Item *new_item= arg->transform(transformer, args);
  if (!new_item)
    return 0;

  /*
    THD::change_item_tree() should be called only if the tree was
    really transformed, i.e. when a new item has been created.
    Otherwise we'll be allocating a lot of unnecessary memory for
    change records at each execution.
  */
  if (arg != new_item)
    current_thd->change_item_tree(&arg, new_item);
  return (this->*transformer)(args);
}


6043 6044 6045 6046 6047 6048 6049
bool Item_insert_value::eq(const Item *item, bool binary_cmp) const
{
  return item->type() == INSERT_VALUE_ITEM &&
    ((Item_default_value *)item)->arg->eq(arg, binary_cmp);
}


6050
bool Item_insert_value::fix_fields(THD *thd, Item **items)
6051
{
6052
  DBUG_ASSERT(fixed == 0);
6053
  /* We should only check that arg is in first table */
6054
  if (!arg->fixed)
6055
  {
6056
    bool res;
6057
    TABLE_LIST *orig_next_table= context->last_name_resolution_table;
6058 6059
    context->last_name_resolution_table= context->first_name_resolution_table;
    res= arg->fix_fields(thd, &arg);
6060
    context->last_name_resolution_table= orig_next_table;
6061 6062
    if (res)
      return TRUE;
6063
  }
6064

6065 6066 6067 6068 6069
  if (arg->type() == REF_ITEM)
  {
    Item_ref *ref= (Item_ref *)arg;
    if (ref->ref[0]->type() != FIELD_ITEM)
    {
6070
      my_error(ER_BAD_FIELD_ERROR, MYF(0), "", "VALUES() function");
6071
      return TRUE;
6072 6073 6074
    }
    arg= ref->ref[0];
  }
6075 6076 6077 6078 6079 6080
  /*
    According to our SQL grammar, VALUES() function can reference
    only to a column.
  */
  DBUG_ASSERT(arg->type() == FIELD_ITEM);

6081
  Item_field *field_arg= (Item_field *)arg;
6082

6083 6084 6085 6086
  if (field_arg->field->table->insert_values)
  {
    Field *def_field= (Field*) sql_alloc(field_arg->field->size_of());
    if (!def_field)
6087
      return TRUE;
6088
    memcpy(def_field, field_arg->field, field_arg->field->size_of());
6089 6090 6091
    def_field->move_field_offset((my_ptrdiff_t)
                                 (def_field->table->insert_values -
                                  def_field->table->record[0]));
6092 6093 6094 6095
    set_field(def_field);
  }
  else
  {
6096
    Field *tmp_field= field_arg->field;
6097
    /* charset doesn't matter here, it's to avoid sigsegv only */
6098 6099 6100 6101 6102 6103 6104
    tmp_field= new Field_null(0, 0, Field::NONE, field_arg->field->field_name,
                          &my_charset_bin);
    if (tmp_field)
    {
      tmp_field->init(field_arg->field->table);
      set_field(tmp_field);
    }
6105
  }
6106
  return FALSE;
6107 6108
}

6109
void Item_insert_value::print(String *str, enum_query_type query_type)
6110
{
6111
  str->append(STRING_WITH_LEN("values("));
6112
  arg->print(str, query_type);
6113 6114 6115
  str->append(')');
}

6116

6117
/**
6118 6119
  Find index of Field object which will be appropriate for item
  representing field of row being changed in trigger.
6120

6121 6122 6123
  @param thd     current thread context
  @param table   table of trigger (and where we looking for fields)
  @param table_grant_info   GRANT_INFO of the subject table
6124

6125
  @note
6126
    This function does almost the same as fix_fields() for Item_field
6127 6128 6129 6130 6131 6132 6133 6134
    but is invoked right after trigger definition parsing. Since at
    this stage we can't say exactly what Field object (corresponding
    to TABLE::record[0] or TABLE::record[1]) should be bound to this
    Item, we only find out index of the Field and then select concrete
    Field object in fix_fields() (by that time Table_trigger_list::old_field/
    new_field should point to proper array of Fields).
    It also binds Item_trigger_field to Table_triggers_list object for
    table of trigger which uses this item.
6135
*/
6136

6137 6138
void Item_trigger_field::setup_field(THD *thd, TABLE *table,
                                     GRANT_INFO *table_grant_info)
6139
{
6140
  /*
6141 6142 6143 6144 6145
    It is too early to mark fields used here, because before execution
    of statement that will invoke trigger other statements may use same
    TABLE object, so all such mark-up will be wiped out.
    So instead we do it in Table_triggers_list::mark_fields_used()
    method which is called during execution of these statements.
6146
  */
6147 6148
  enum_mark_columns save_mark_used_columns= thd->mark_used_columns;
  thd->mark_used_columns= MARK_COLUMNS_NONE;
6149 6150 6151 6152
  /*
    Try to find field by its name and if it will be found
    set field_idx properly.
  */
6153
  (void)find_field_in_table(thd, table, field_name, (uint) strlen(field_name),
6154
                            0, &field_idx);
6155
  thd->mark_used_columns= save_mark_used_columns;
6156
  triggers= table->triggers;
6157
  table_grants= table_grant_info;
6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169
}


bool Item_trigger_field::eq(const Item *item, bool binary_cmp) const
{
  return item->type() == TRIGGER_FIELD_ITEM &&
         row_version == ((Item_trigger_field *)item)->row_version &&
         !my_strcasecmp(system_charset_info, field_name,
                        ((Item_trigger_field *)item)->field_name);
}


6170
void Item_trigger_field::set_required_privilege(bool rw)
6171 6172 6173 6174 6175 6176 6177 6178 6179
{
  /*
    Require SELECT and UPDATE privilege if this field will be read and
    set, and only UPDATE privilege for setting the field.
  */
  want_privilege= (rw ? SELECT_ACL | UPDATE_ACL : UPDATE_ACL);
}


6180
bool Item_trigger_field::set_value(THD *thd, sp_rcontext * /*ctx*/, Item **it)
6181
{
6182
  Item *item= sp_prepare_func_item(thd, it);
6183 6184 6185 6186 6187 6188

  return (!item || (!fixed && fix_fields(thd, 0)) ||
          (item->save_in_field(field, 0) < 0));
}


6189
bool Item_trigger_field::fix_fields(THD *thd, Item **items)
6190 6191 6192 6193 6194 6195
{
  /*
    Since trigger is object tightly associated with TABLE object most
    of its set up can be performed during trigger loading i.e. trigger
    parsing! So we have little to do in fix_fields. :)
  */
6196

6197
  DBUG_ASSERT(fixed == 0);
6198

6199 6200
  /* Set field. */

6201
  if (field_idx != (uint)-1)
6202
  {
6203 6204 6205 6206 6207 6208 6209 6210
#ifndef NO_EMBEDDED_ACCESS_CHECKS
    /*
      Check access privileges for the subject table. We check privileges only
      in runtime.
    */

    if (table_grants)
    {
6211
      table_grants->want_privilege= want_privilege;
6212

6213 6214
      if (check_grant_column(thd, table_grants, triggers->trigger_table->s->db.str,
                             triggers->trigger_table->s->table_name.str, field_name,
6215 6216 6217 6218 6219
                             strlen(field_name), thd->security_ctx))
        return TRUE;
    }
#endif // NO_EMBEDDED_ACCESS_CHECKS

6220 6221
    field= (row_version == OLD_ROW) ? triggers->old_field[field_idx] :
                                      triggers->new_field[field_idx];
6222 6223
    set_field(field);
    fixed= 1;
6224
    return FALSE;
6225 6226 6227 6228
  }

  my_error(ER_BAD_FIELD_ERROR, MYF(0), field_name,
           (row_version == NEW_ROW) ? "NEW" : "OLD");
6229
  return TRUE;
6230 6231 6232
}


6233
void Item_trigger_field::print(String *str, enum_query_type query_type)
6234 6235 6236 6237 6238 6239 6240 6241 6242
{
  str->append((row_version == NEW_ROW) ? "NEW" : "OLD", 3);
  str->append('.');
  str->append(field_name);
}


void Item_trigger_field::cleanup()
{
6243
  want_privilege= original_privilege;
6244 6245 6246 6247 6248 6249 6250 6251
  /*
    Since special nature of Item_trigger_field we should not do most of
    things from Item_field::cleanup() or Item_ident::cleanup() here.
  */
  Item::cleanup();
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
6252 6253 6254 6255
Item_result item_cmp_type(Item_result a,Item_result b)
{
  if (a == STRING_RESULT && b == STRING_RESULT)
    return STRING_RESULT;
6256
  if (a == INT_RESULT && b == INT_RESULT)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6257
    return INT_RESULT;
6258 6259
  else if (a == ROW_RESULT || b == ROW_RESULT)
    return ROW_RESULT;
6260 6261 6262
  if ((a == INT_RESULT || a == DECIMAL_RESULT) &&
      (b == INT_RESULT || b == DECIMAL_RESULT))
    return DECIMAL_RESULT;
6263
  return REAL_RESULT;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6264 6265 6266
}


6267
void resolve_const_item(THD *thd, Item **ref, Item *comp_item)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6268
{
6269
  Item *item= *ref;
6270
  Item *new_item= NULL;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6271
  if (item->basic_const_item())
6272
    return;                                     // Can't be better
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6273 6274 6275 6276
  Item_result res_type=item_cmp_type(comp_item->result_type(),
				     item->result_type());
  char *name=item->name;			// Alloced by sql_alloc

6277
  switch (res_type) {
6278
  case STRING_RESULT:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6279 6280
  {
    char buff[MAX_FIELD_WIDTH];
6281
    String tmp(buff,sizeof(buff),&my_charset_bin),*result;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6282 6283
    result=item->val_str(&tmp);
    if (item->null_value)
6284 6285 6286 6287 6288 6289 6290
      new_item= new Item_null(name);
    else
    {
      uint length= result->length();
      char *tmp_str= sql_strmake(result->ptr(), length);
      new_item= new Item_string(name, tmp_str, length, result->charset());
    }
6291
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6292
  }
6293
  case INT_RESULT:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6294 6295 6296 6297
  {
    longlong result=item->val_int();
    uint length=item->max_length;
    bool null_value=item->null_value;
6298 6299
    new_item= (null_value ? (Item*) new Item_null(name) :
               (Item*) new Item_int(name, result, length));
6300
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6301
  }
6302
  case ROW_RESULT:
6303
  if (item->type() == Item::ROW_ITEM && comp_item->type() == Item::ROW_ITEM)
6304
  {
6305 6306 6307 6308 6309 6310 6311 6312
    /*
      Substitute constants only in Item_rows. Don't affect other Items
      with ROW_RESULT (eg Item_singlerow_subselect).

      For such Items more optimal is to detect if it is constant and replace
      it with Item_row. This would optimize queries like this:
      SELECT * FROM t1 WHERE (a,b) = (SELECT a,b FROM t2 LIMIT 1);
    */
6313 6314 6315
    Item_row *item_row= (Item_row*) item;
    Item_row *comp_item_row= (Item_row*) comp_item;
    uint col;
6316 6317 6318
    new_item= 0;
    /*
      If item and comp_item are both Item_rows and have same number of cols
6319 6320 6321
      then process items in Item_row one by one.
      We can't ignore NULL values here as this item may be used with <=>, in
      which case NULL's are significant.
6322
    */
6323 6324 6325 6326
    DBUG_ASSERT(item->result_type() == comp_item->result_type());
    DBUG_ASSERT(item_row->cols() == comp_item_row->cols());
    col= item_row->cols();
    while (col-- > 0)
6327 6328
      resolve_const_item(thd, item_row->addr(col),
                         comp_item_row->element_index(col));
6329
    break;
6330
  }
6331
  /* Fallthrough */
6332
  case REAL_RESULT:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6333
  {						// It must REAL_RESULT
6334
    double result= item->val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6335 6336
    uint length=item->max_length,decimals=item->decimals;
    bool null_value=item->null_value;
6337
    new_item= (null_value ? (Item*) new Item_null(name) : (Item*)
6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353
               new Item_float(name, result, decimals, length));
    break;
  }
  case DECIMAL_RESULT:
  {
    my_decimal decimal_value;
    my_decimal *result= item->val_decimal(&decimal_value);
    uint length= item->max_length, decimals= item->decimals;
    bool null_value= item->null_value;
    new_item= (null_value ?
               (Item*) new Item_null(name) :
               (Item*) new Item_decimal(name, result, length, decimals));
    break;
  }
  default:
    DBUG_ASSERT(0);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6354
  }
6355 6356
  if (new_item)
    thd->change_item_tree(ref, new_item);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6357 6358
}

6359 6360 6361 6362
/**
  Return true if the value stored in the field is equal to the const
  item.

bk@work.mysql.com's avatar
bk@work.mysql.com committed
6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375
  We need to use this on the range optimizer because in some cases
  we can't store the value in the field without some precision/character loss.
*/

bool field_is_equal_to_item(Field *field,Item *item)
{

  Item_result res_type=item_cmp_type(field->result_type(),
				     item->result_type());
  if (res_type == STRING_RESULT)
  {
    char item_buff[MAX_FIELD_WIDTH];
    char field_buff[MAX_FIELD_WIDTH];
6376 6377
    String item_tmp(item_buff,sizeof(item_buff),&my_charset_bin),*item_result;
    String field_tmp(field_buff,sizeof(field_buff),&my_charset_bin);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6378 6379 6380
    item_result=item->val_str(&item_tmp);
    if (item->null_value)
      return 1;					// This must be true
6381
    field->val_str(&field_tmp);
monty@mysql.com's avatar
monty@mysql.com committed
6382
    return !stringcmp(&field_tmp,item_result);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6383 6384 6385
  }
  if (res_type == INT_RESULT)
    return 1;					// Both where of type int
6386 6387 6388 6389 6390 6391 6392 6393 6394 6395
  if (res_type == DECIMAL_RESULT)
  {
    my_decimal item_buf, *item_val,
               field_buf, *field_val;
    item_val= item->val_decimal(&item_buf);
    if (item->null_value)
      return 1;					// This must be true
    field_val= field->val_decimal(&field_buf);
    return !my_decimal_cmp(item_val, field_val);
  }
6396
  double result= item->val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6397 6398 6399 6400 6401
  if (item->null_value)
    return 1;
  return result == field->val_real();
}

6402
Item_cache* Item_cache::get_cache(const Item *item)
6403
{
6404
  switch (item->result_type()) {
6405 6406 6407 6408
  case INT_RESULT:
    return new Item_cache_int();
  case REAL_RESULT:
    return new Item_cache_real();
6409 6410
  case DECIMAL_RESULT:
    return new Item_cache_decimal();
6411
  case STRING_RESULT:
6412
    return new Item_cache_str(item);
6413 6414
  case ROW_RESULT:
    return new Item_cache_row();
6415 6416 6417 6418 6419 6420 6421
  default:
    // should never be in real life
    DBUG_ASSERT(0);
    return 0;
  }
}

6422

6423
void Item_cache::print(String *str, enum_query_type query_type)
6424
{
6425
  str->append(STRING_WITH_LEN("<cache>("));
6426
  if (example)
6427
    example->print(str, query_type);
6428
  else
6429
    Item::print(str, query_type);
6430 6431 6432 6433 6434 6435 6436 6437
  str->append(')');
}


void Item_cache_int::store(Item *item)
{
  value= item->val_int_result();
  null_value= item->null_value;
6438 6439 6440 6441
  unsigned_flag= item->unsigned_flag;
}


6442 6443 6444 6445 6446 6447 6448 6449
void Item_cache_int::store(Item *item, longlong val_arg)
{
  value= val_arg;
  null_value= item->null_value;
  unsigned_flag= item->unsigned_flag;
}


6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462
String *Item_cache_int::val_str(String *str)
{
  DBUG_ASSERT(fixed == 1);
  str->set(value, default_charset());
  return str;
}


my_decimal *Item_cache_int::val_decimal(my_decimal *decimal_val)
{
  DBUG_ASSERT(fixed == 1);
  int2my_decimal(E_DEC_FATAL_ERROR, value, unsigned_flag, decimal_val);
  return decimal_val;
6463 6464 6465 6466 6467 6468 6469 6470 6471 6472
}


void Item_cache_real::store(Item *item)
{
  value= item->val_result();
  null_value= item->null_value;
}


6473 6474 6475
longlong Item_cache_real::val_int()
{
  DBUG_ASSERT(fixed == 1);
6476
  return (longlong) rint(value);
6477 6478 6479 6480 6481 6482
}


String* Item_cache_real::val_str(String *str)
{
  DBUG_ASSERT(fixed == 1);
6483
  str->set_real(value, decimals, default_charset());
6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498
  return str;
}


my_decimal *Item_cache_real::val_decimal(my_decimal *decimal_val)
{
  DBUG_ASSERT(fixed == 1);
  double2my_decimal(E_DEC_FATAL_ERROR, value, decimal_val);
  return decimal_val;
}


void Item_cache_decimal::store(Item *item)
{
  my_decimal *val= item->val_decimal_result(&decimal_value);
6499
  if (!(null_value= item->null_value) && val != &decimal_value)
6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534
    my_decimal2decimal(val, &decimal_value);
}

double Item_cache_decimal::val_real()
{
  DBUG_ASSERT(fixed);
  double res;
  my_decimal2double(E_DEC_FATAL_ERROR, &decimal_value, &res);
  return res;
}

longlong Item_cache_decimal::val_int()
{
  DBUG_ASSERT(fixed);
  longlong res;
  my_decimal2int(E_DEC_FATAL_ERROR, &decimal_value, unsigned_flag, &res);
  return res;
}

String* Item_cache_decimal::val_str(String *str)
{
  DBUG_ASSERT(fixed);
  my_decimal_round(E_DEC_FATAL_ERROR, &decimal_value, decimals, FALSE,
                   &decimal_value);
  my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value, 0, 0, 0, str);
  return str;
}

my_decimal *Item_cache_decimal::val_decimal(my_decimal *val)
{
  DBUG_ASSERT(fixed);
  return &decimal_value;
}


6535 6536
void Item_cache_str::store(Item *item)
{
bell@sanja.is.com.ua's avatar
merge  
bell@sanja.is.com.ua committed
6537
  value_buff.set(buffer, sizeof(buffer), item->collation.collation);
6538
  value= item->str_result(&value_buff);
6539 6540
  if ((null_value= item->null_value))
    value= 0;
6541
  else if (value != &value_buff)
6542 6543 6544 6545 6546 6547 6548 6549 6550
  {
    /*
      We copy string value to avoid changing value if 'item' is table field
      in queries like following (where t1.c is varchar):
      select a, 
             (select a,b,c from t1 where t1.a=t2.a) = ROW(a,2,'a'),
             (select c from t1 where a=t2.a)
        from t2;
    */
6551 6552
    value_buff.copy(*value);
    value= &value_buff;
6553 6554
  }
}
6555

6556
double Item_cache_str::val_real()
6557 6558
{
  DBUG_ASSERT(fixed == 1);
6559 6560
  int err_not_used;
  char *end_not_used;
6561
  if (value)
6562
    return my_strntod(value->charset(), (char*) value->ptr(),
6563 6564
		      value->length(), &end_not_used, &err_not_used);
  return (double) 0;
6565
}
6566 6567


6568 6569
longlong Item_cache_str::val_int()
{
6570
  DBUG_ASSERT(fixed == 1);
6571
  int err;
6572 6573
  if (value)
    return my_strntoll(value->charset(), value->ptr(),
6574
		       value->length(), 10, (char**) 0, &err);
6575 6576 6577
  else
    return (longlong)0;
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6578

6579 6580 6581 6582 6583 6584 6585 6586 6587 6588
my_decimal *Item_cache_str::val_decimal(my_decimal *decimal_val)
{
  DBUG_ASSERT(fixed == 1);
  if (value)
    string2my_decimal(E_DEC_FATAL_ERROR, value, decimal_val);
  else
    decimal_val= 0;
  return decimal_val;
}

6589

6590 6591 6592 6593 6594 6595 6596 6597
int Item_cache_str::save_in_field(Field *field, bool no_conversions)
{
  int res= Item_cache::save_in_field(field, no_conversions);
  return (is_varbinary && field->type() == MYSQL_TYPE_STRING &&
          value->length() < field->field_length) ? 1 : res;
}


6598 6599
bool Item_cache_row::allocate(uint num)
{
6600
  item_count= num;
6601
  THD *thd= current_thd;
6602 6603
  return (!(values= 
	    (Item_cache **) thd->calloc(sizeof(Item_cache *)*item_count)));
6604 6605
}

6606

6607 6608
bool Item_cache_row::setup(Item * item)
{
6609
  example= item;
6610 6611
  if (!values && allocate(item->cols()))
    return 1;
6612
  for (uint i= 0; i < item_count; i++)
6613
  {
6614
    Item *el= item->element_index(i);
6615
    Item_cache *tmp;
6616
    if (!(tmp= values[i]= Item_cache::get_cache(el)))
6617
      return 1;
6618
    tmp->setup(el);
6619 6620 6621 6622
  }
  return 0;
}

6623

6624 6625 6626 6627
void Item_cache_row::store(Item * item)
{
  null_value= 0;
  item->bring_value();
6628
  for (uint i= 0; i < item_count; i++)
6629
  {
6630
    values[i]->store(item->element_index(i));
6631 6632 6633 6634
    null_value|= values[i]->null_value;
  }
}

6635

6636 6637 6638 6639 6640
void Item_cache_row::illegal_method_call(const char *method)
{
  DBUG_ENTER("Item_cache_row::illegal_method_call");
  DBUG_PRINT("error", ("!!! %s method was called for row item", method));
  DBUG_ASSERT(0);
6641
  my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
6642 6643 6644
  DBUG_VOID_RETURN;
}

6645

6646 6647
bool Item_cache_row::check_cols(uint c)
{
6648
  if (c != item_count)
6649
  {
6650
    my_error(ER_OPERAND_COLUMNS, MYF(0), c);
6651 6652 6653 6654 6655
    return 1;
  }
  return 0;
}

6656

6657 6658
bool Item_cache_row::null_inside()
{
6659
  for (uint i= 0; i < item_count; i++)
6660 6661 6662 6663 6664 6665 6666 6667
  {
    if (values[i]->cols() > 1)
    {
      if (values[i]->null_inside())
	return 1;
    }
    else
    {
6668
      values[i]->update_null_value();
6669 6670 6671 6672 6673 6674 6675
      if (values[i]->null_value)
	return 1;
    }
  }
  return 0;
}

6676

6677 6678
void Item_cache_row::bring_value()
{
6679
  for (uint i= 0; i < item_count; i++)
6680 6681 6682
    values[i]->bring_value();
  return;
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
6683

6684

6685 6686
Item_type_holder::Item_type_holder(THD *thd, Item *item)
  :Item(thd, item), enum_set_typelib(0), fld_type(get_real_type(item))
6687 6688
{
  DBUG_ASSERT(item->fixed);
6689
  maybe_null= item->maybe_null;
6690
  collation.set(item->collation);
6691
  get_full_info(item);
6692 6693 6694
  /* fix variable decimals which always is NOT_FIXED_DEC */
  if (Field::result_merge_type(fld_type) == INT_RESULT)
    decimals= 0;
6695
  prev_decimal_int_part= item->decimal_int_part();
6696
#ifdef HAVE_SPATIAL
6697
  if (item->field_type() == MYSQL_TYPE_GEOMETRY)
6698
    geometry_type= item->get_geometry_type();
6699
#endif /* HAVE_SPATIAL */
6700 6701 6702
}


6703 6704
/**
  Return expression type of Item_type_holder.
6705

6706 6707
  @return
    Item_result (type of internal MySQL expression result)
6708 6709
*/

6710
Item_result Item_type_holder::result_type() const
6711
{
6712
  return Field::result_merge_type(fld_type);
6713
}
6714

6715

6716 6717
/**
  Find real field type of item.
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6718

6719
  @return
6720
    type of field which should be created to store item value
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6721 6722
*/

6723
enum_field_types Item_type_holder::get_real_type(Item *item)
6724
{
6725
  switch(item->type())
6726
  {
6727
  case FIELD_ITEM:
6728
  {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6729
    /*
6730 6731
      Item_fields::field_type ask Field_type() but sometimes field return
      a different type, like for enum/set, so we need to ask real type.
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6732
    */
6733 6734
    Field *field= ((Item_field *) item)->field;
    enum_field_types type= field->real_type();
6735 6736
    if (field->is_created_from_null_item)
      return MYSQL_TYPE_NULL;
6737 6738 6739 6740
    /* work around about varchar type field detection */
    if (type == MYSQL_TYPE_STRING && field->type() == MYSQL_TYPE_VAR_STRING)
      return MYSQL_TYPE_VAR_STRING;
    return type;
6741
  }
6742
  case SUM_FUNC_ITEM:
6743
  {
6744 6745 6746 6747
    /*
      Argument of aggregate function sometimes should be asked about field
      type
    */
6748 6749
    Item_sum *item_sum= (Item_sum *) item;
    if (item_sum->keep_field_type())
6750 6751 6752 6753
      return get_real_type(item_sum->args[0]);
    break;
  }
  case FUNC_ITEM:
6754
    if (((Item_func *) item)->functype() == Item_func::GUSERVAR_FUNC)
6755
    {
6756
      /*
6757 6758 6759 6760
        There are work around of problem with changing variable type on the
        fly and variable always report "string" as field type to get
        acceptable information for client in send_field, so we make field
        type from expression type.
6761
      */
6762
      switch (item->result_type()) {
6763 6764 6765 6766 6767 6768
      case STRING_RESULT:
        return MYSQL_TYPE_VAR_STRING;
      case INT_RESULT:
        return MYSQL_TYPE_LONGLONG;
      case REAL_RESULT:
        return MYSQL_TYPE_DOUBLE;
6769 6770
      case DECIMAL_RESULT:
        return MYSQL_TYPE_NEWDECIMAL;
6771 6772 6773 6774 6775
      case ROW_RESULT:
      default:
        DBUG_ASSERT(0);
        return MYSQL_TYPE_VAR_STRING;
      }
6776
    }
6777 6778 6779
    break;
  default:
    break;
6780
  }
6781
  return item->field_type();
6782 6783
}

6784
/**
6785 6786
  Find field type which can carry current Item_type_holder type and
  type of given Item.
6787

6788 6789
  @param thd     thread handler
  @param item    given item to join its parameters with this item ones
6790

6791
  @retval
6792
    TRUE   error - types are incompatible
6793
  @retval
6794
    FALSE  OK
6795 6796
*/

6797
bool Item_type_holder::join_types(THD *thd, Item *item)
6798
{
6799 6800
  uint max_length_orig= max_length;
  uint decimals_orig= decimals;
6801 6802 6803 6804 6805 6806 6807
  DBUG_ENTER("Item_type_holder::join_types");
  DBUG_PRINT("info:", ("was type %d len %d, dec %d name %s",
                       fld_type, max_length, decimals,
                       (name ? name : "<NULL>")));
  DBUG_PRINT("info:", ("in type %d len %d, dec %d",
                       get_real_type(item),
                       item->max_length, item->decimals));
6808
  fld_type= Field::field_type_merge(fld_type, get_real_type(item));
6809
  {
6810 6811 6812 6813 6814
    int item_decimals= item->decimals;
    /* fix variable decimals which always is NOT_FIXED_DEC */
    if (Field::result_merge_type(fld_type) == INT_RESULT)
      item_decimals= 0;
    decimals= max(decimals, item_decimals);
6815
  }
6816
  if (Field::result_merge_type(fld_type) == DECIMAL_RESULT)
6817
  {
6818 6819 6820 6821 6822 6823
    decimals= min(max(decimals, item->decimals), DECIMAL_MAX_SCALE);
    int precision= min(max(prev_decimal_int_part, item->decimal_int_part())
                       + decimals, DECIMAL_MAX_PRECISION);
    unsigned_flag&= item->unsigned_flag;
    max_length= my_decimal_precision_to_length(precision, decimals,
                                               unsigned_flag);
6824
  }
6825

6826 6827 6828
  switch (Field::result_merge_type(fld_type))
  {
  case STRING_RESULT:
6829
  {
6830
    const char *old_cs, *old_derivation;
6831
    uint32 old_max_chars= max_length / collation.collation->mbmaxlen;
6832 6833
    old_cs= collation.collation->name;
    old_derivation= collation.derivation_name();
6834
    if (collation.aggregate(item->collation, MY_COLL_ALLOW_CONV))
6835
    {
6836
      my_error(ER_CANT_AGGREGATE_2COLLATIONS, MYF(0),
6837 6838 6839 6840
	       old_cs, old_derivation,
	       item->collation.collation->name,
	       item->collation.derivation_name(),
	       "UNION");
6841
      DBUG_RETURN(TRUE);
6842
    }
6843 6844 6845 6846 6847
    /*
      To figure out max_length, we have to take into account possible
      expansion of the size of the values because of character set
      conversions.
     */
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
6848 6849 6850 6851 6852 6853 6854 6855 6856
    if (collation.collation != &my_charset_bin)
    {
      max_length= max(old_max_chars * collation.collation->mbmaxlen,
                      display_length(item) /
                      item->collation.collation->mbmaxlen *
                      collation.collation->mbmaxlen);
    }
    else
      set_if_bigger(max_length, display_length(item));
6857
    break;
6858
  }
6859 6860 6861 6862 6863 6864
  case REAL_RESULT:
  {
    if (decimals != NOT_FIXED_DEC)
    {
      int delta1= max_length_orig - decimals_orig;
      int delta2= item->max_length - item->decimals;
6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875
      max_length= max(delta1, delta2) + decimals;
      if (fld_type == MYSQL_TYPE_FLOAT && max_length > FLT_DIG + 2) 
      {
        max_length= FLT_DIG + 6;
        decimals= NOT_FIXED_DEC;
      } 
      if (fld_type == MYSQL_TYPE_DOUBLE && max_length > DBL_DIG + 2) 
      {
        max_length= DBL_DIG + 7;
        decimals= NOT_FIXED_DEC;
      }
6876 6877 6878 6879
    }
    else
      max_length= (fld_type == MYSQL_TYPE_FLOAT) ? FLT_DIG+6 : DBL_DIG+7;
    break;
6880
  }
6881 6882
  default:
    max_length= max(max_length, display_length(item));
6883
  };
6884 6885
  maybe_null|= item->maybe_null;
  get_full_info(item);
6886 6887 6888

  /* Remember decimal integer part to be used in DECIMAL_RESULT handleng */
  prev_decimal_int_part= decimal_int_part();
6889 6890
  DBUG_PRINT("info", ("become type: %d  len: %u  dec: %u",
                      (int) fld_type, max_length, (uint) decimals));
6891
  DBUG_RETURN(FALSE);
6892 6893
}

6894 6895
/**
  Calculate lenth for merging result for given Item type.
6896

6897
  @param item  Item for length detection
6898

6899
  @return
6900 6901
    length
*/
6902

6903
uint32 Item_type_holder::display_length(Item *item)
6904 6905
{
  if (item->type() == Item::FIELD_ITEM)
6906
    return ((Item_field *)item)->max_disp_length();
6907

6908
  switch (item->field_type())
6909
  {
6910 6911 6912 6913 6914 6915 6916
  case MYSQL_TYPE_DECIMAL:
  case MYSQL_TYPE_TIMESTAMP:
  case MYSQL_TYPE_DATE:
  case MYSQL_TYPE_TIME:
  case MYSQL_TYPE_DATETIME:
  case MYSQL_TYPE_YEAR:
  case MYSQL_TYPE_NEWDATE:
6917 6918 6919
  case MYSQL_TYPE_VARCHAR:
  case MYSQL_TYPE_BIT:
  case MYSQL_TYPE_NEWDECIMAL:
6920 6921 6922 6923 6924 6925 6926 6927 6928
  case MYSQL_TYPE_ENUM:
  case MYSQL_TYPE_SET:
  case MYSQL_TYPE_TINY_BLOB:
  case MYSQL_TYPE_MEDIUM_BLOB:
  case MYSQL_TYPE_LONG_BLOB:
  case MYSQL_TYPE_BLOB:
  case MYSQL_TYPE_VAR_STRING:
  case MYSQL_TYPE_STRING:
  case MYSQL_TYPE_GEOMETRY:
6929
    return item->max_length;
6930 6931 6932 6933 6934
  case MYSQL_TYPE_TINY:
    return 4;
  case MYSQL_TYPE_SHORT:
    return 6;
  case MYSQL_TYPE_LONG:
6935
    return MY_INT32_NUM_DECIMAL_DIGITS;
6936 6937 6938
  case MYSQL_TYPE_FLOAT:
    return 25;
  case MYSQL_TYPE_DOUBLE:
6939
    return 53;
6940
  case MYSQL_TYPE_NULL:
6941
    return 0;
6942
  case MYSQL_TYPE_LONGLONG:
6943
    return 20;
6944 6945
  case MYSQL_TYPE_INT24:
    return 8;
6946 6947 6948 6949 6950
  default:
    DBUG_ASSERT(0); // we should never go there
    return 0;
  }
}
6951

6952

6953
/**
6954
  Make temporary table field according collected information about type
6955
  of UNION result.
6956

6957
  @param table  temporary table for which we create fields
6958

6959
  @return
6960 6961 6962 6963 6964
    created field
*/

Field *Item_type_holder::make_field_by_type(TABLE *table)
{
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6965 6966 6967 6968
  /*
    The field functions defines a field to be not null if null_ptr is not 0
  */
  uchar *null_ptr= maybe_null ? (uchar*) "" : 0;
6969 6970 6971
  Field *field;

  switch (fld_type) {
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6972
  case MYSQL_TYPE_ENUM:
6973
    DBUG_ASSERT(enum_set_typelib);
6974
    field= new Field_enum((uchar *) 0, max_length, null_ptr, 0,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6975
                          Field::NONE, name,
6976
                          get_enum_pack_length(enum_set_typelib->count),
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6977
                          enum_set_typelib, collation.collation);
6978 6979 6980
    if (field)
      field->init(table);
    return field;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6981 6982
  case MYSQL_TYPE_SET:
    DBUG_ASSERT(enum_set_typelib);
6983
    field= new Field_set((uchar *) 0, max_length, null_ptr, 0,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6984
                         Field::NONE, name,
6985
                         get_set_pack_length(enum_set_typelib->count),
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6986
                         enum_set_typelib, collation.collation);
6987 6988 6989
    if (field)
      field->init(table);
    return field;
6990 6991
  case MYSQL_TYPE_NULL:
    return make_string_field(table);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
6992 6993
  default:
    break;
6994
  }
6995
  return tmp_table_field_from_field_type(table, 0);
6996 6997 6998
}


6999
/**
7000
  Get full information from Item about enum/set fields to be able to create
7001
  them later.
7002

7003
  @param item    Item for information collection
7004 7005 7006 7007 7008 7009
*/
void Item_type_holder::get_full_info(Item *item)
{
  if (fld_type == MYSQL_TYPE_ENUM ||
      fld_type == MYSQL_TYPE_SET)
  {
7010 7011 7012 7013
    if (item->type() == Item::SUM_FUNC_ITEM &&
        (((Item_sum*)item)->sum_func() == Item_sum::MAX_FUNC ||
         ((Item_sum*)item)->sum_func() == Item_sum::MIN_FUNC))
      item = ((Item_sum*)item)->args[0];
7014
    /*
7015 7016
      We can have enum/set type after merging only if we have one enum|set
      field (or MIN|MAX(enum|set field)) and number of NULL fields
7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032
    */
    DBUG_ASSERT((enum_set_typelib &&
                 get_real_type(item) == MYSQL_TYPE_NULL) ||
                (!enum_set_typelib &&
                 item->type() == Item::FIELD_ITEM &&
                 (get_real_type(item) == MYSQL_TYPE_ENUM ||
                  get_real_type(item) == MYSQL_TYPE_SET) &&
                 ((Field_enum*)((Item_field *) item)->field)->typelib));
    if (!enum_set_typelib)
    {
      enum_set_typelib= ((Field_enum*)((Item_field *) item)->field)->typelib;
    }
  }
}


7033
double Item_type_holder::val_real()
7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045
{
  DBUG_ASSERT(0); // should never be called
  return 0.0;
}


longlong Item_type_holder::val_int()
{
  DBUG_ASSERT(0); // should never be called
  return 0;
}

7046 7047 7048 7049 7050
my_decimal *Item_type_holder::val_decimal(my_decimal *)
{
  DBUG_ASSERT(0); // should never be called
  return 0;
}
7051 7052 7053 7054 7055 7056 7057

String *Item_type_holder::val_str(String*)
{
  DBUG_ASSERT(0); // should never be called
  return 0;
}

7058 7059 7060 7061 7062 7063 7064 7065
void Item_result_field::cleanup()
{
  DBUG_ENTER("Item_result_field::cleanup()");
  Item::cleanup();
  result_field= 0;
  DBUG_VOID_RETURN;
}

7066 7067
/**
  Dummy error processor used by default by Name_resolution_context.
7068

7069
  @note
7070 7071 7072 7073 7074 7075
    do nothing
*/

void dummy_error_processor(THD *thd, void *data)
{}

7076 7077 7078
/**
  Wrapper of hide_view_error call for Name_resolution_context error
  processor.
7079

7080
  @note
7081 7082 7083 7084 7085 7086 7087 7088
    hide view underlying tables details in error messages
*/

void view_error_processor(THD *thd, void *data)
{
  ((TABLE_LIST *)data)->hide_view_error(thd);
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
7089 7090 7091 7092
/*****************************************************************************
** Instantiate templates
*****************************************************************************/

7093
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7094 7095
template class List<Item>;
template class List_iterator<Item>;
monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
7096
template class List_iterator_fast<Item>;
7097
template class List_iterator_fast<Item_field>;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
7098 7099
template class List<List_item>;
#endif