item.cc 57 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
unknown's avatar
unknown committed
2

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

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

unknown's avatar
unknown committed
13 14 15 16 17 18 19 20 21 22 23 24 25
   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 */


#ifdef __GNUC__
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
#include <m_ctype.h>
#include "my_dir.h"

26 27
static void mark_as_dependent(THD *thd,
			      SELECT_LEX *last, SELECT_LEX *current,
unknown's avatar
unknown committed
28 29
			      Item_ident *item);

unknown's avatar
unknown committed
30 31 32 33 34 35 36 37 38 39 40
/*****************************************************************************
** Item functions
*****************************************************************************/

/* Init all special items */

void item_init(void)
{
  item_user_lock_init();
}

41 42
Item::Item():
  fixed(0)
unknown's avatar
unknown committed
43
{
44
  marker= 0;
45
  maybe_null=null_value=with_sum_func=unsigned_flag=0;
46
  collation.set(default_charset(), DERIVATION_COERCIBLE);
47 48
  name= 0;
  decimals= 0; max_length= 0;
49 50 51 52

  /* Put item in free list so that we can free all items at end */
  THD *thd= current_thd;
  next= thd->free_list;
53
  thd->free_list= this;
54
  /*
55
    Item constructor can be called during execution other then SQL_COM
56
    command => we should check thd->lex->current_select on zero (thd->lex
unknown's avatar
unknown committed
57
    can be uninitialised)
58
  */
59
  if (thd->lex->current_select)
60 61
  {
    SELECT_LEX_NODE::enum_parsing_place place= 
62
      thd->lex->current_select->parsing_place;
63 64
    if (place == SELECT_LEX_NODE::SELECT_LIST ||
	place == SELECT_LEX_NODE::IN_HAVING)
65
      thd->lex->current_select->select_n_having_items++;
66
  }
unknown's avatar
unknown committed
67 68
}

69 70 71 72 73
/*
  Constructor used by Item_field, Item_ref & agregate (sum) functions.
  Used for duplicating lists in processing queries with temporary
  tables
*/
74 75 76 77 78 79 80 81 82 83 84 85
Item::Item(THD *thd, Item *item):
  str_value(item->str_value),
  name(item->name),
  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),
  collation(item->collation)
86
{
87
  next= thd->free_list;				// Put in free list
88
  thd->free_list= this;
89 90
}

unknown's avatar
unknown committed
91 92 93 94 95 96

void Item::print_item_w_name(String *str)
{
  print(str);
  if (name)
  {
97
    str->append(" AS `", 5);
unknown's avatar
unknown committed
98 99 100 101 102 103
    str->append(name);
    str->append('`');
  }
}


unknown's avatar
unknown committed
104 105
Item_ident::Item_ident(const char *db_name_par,const char *table_name_par,
		       const char *field_name_par)
unknown's avatar
unknown committed
106
  :orig_db_name(db_name_par), orig_table_name(table_name_par), 
107 108 109 110
   orig_field_name(field_name_par), changed_during_fix_field(0), 
   db_name(db_name_par), table_name(table_name_par), 
   field_name(field_name_par), cached_field_index(NO_CACHED_FIELD_INDEX), 
   cached_table(0), depended_from(0)
unknown's avatar
unknown committed
111 112 113 114
{
  name = (char*) field_name_par;
}

115
// Constructor used by Item_field & Item_ref (see Item comment)
116 117
Item_ident::Item_ident(THD *thd, Item_ident *item)
  :Item(thd, item),
118 119 120
   orig_db_name(item->orig_db_name),
   orig_table_name(item->orig_table_name), 
   orig_field_name(item->orig_field_name),
121 122 123 124
   changed_during_fix_field(0),
   db_name(item->db_name),
   table_name(item->table_name),
   field_name(item->field_name),
125
   cached_field_index(item->cached_field_index),
126
   cached_table(item->cached_table),
127
   depended_from(item->depended_from)
128
{}
129

130 131
void Item_ident::cleanup()
{
unknown's avatar
unknown committed
132 133 134 135 136
  DBUG_ENTER("Item_ident::cleanup");
  DBUG_PRINT("enter", ("b:%s(%s), t:%s(%s), f:%s(%s)",
		       db_name, orig_db_name,
		       table_name, orig_table_name,
		       field_name, orig_field_name));
137 138 139 140 141 142
  Item::cleanup();
  if (changed_during_fix_field)
  {
    *changed_during_fix_field= this;
    changed_during_fix_field= 0;
  }
143 144 145
  db_name= orig_db_name; 
  table_name= orig_table_name;
  field_name= orig_field_name;
unknown's avatar
unknown committed
146
  DBUG_VOID_RETURN;
147 148
}

unknown's avatar
unknown committed
149 150 151 152 153
bool Item_ident::remove_dependence_processor(byte * arg)
{
  DBUG_ENTER("Item_ident::remove_dependence_processor");
  if (depended_from == (st_select_lex *) arg)
    depended_from= 0;
154
  DBUG_RETURN(0);
unknown's avatar
unknown committed
155 156 157
}


unknown's avatar
unknown committed
158 159 160 161
bool Item::check_cols(uint c)
{
  if (c != 1)
  {
unknown's avatar
unknown committed
162
    my_error(ER_OPERAND_COLUMNS, MYF(0), c);
unknown's avatar
unknown committed
163 164 165 166 167
    return 1;
  }
  return 0;
}

unknown's avatar
unknown committed
168 169

void Item::set_name(const char *str, uint length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
170 171 172
{
  if (!length)
  {
unknown's avatar
unknown committed
173 174 175 176 177 178 179 180
    /* Empty string, used by AS or internal function like last_insert_id() */
    name= (char*) str;
    return;
  }
  while (length && !my_isgraph(cs,*str))
  {						// Fix problem with yacc
    length--;
    str++;
unknown's avatar
unknown committed
181
  }
unknown's avatar
unknown committed
182 183 184 185 186 187 188 189 190
  if (!my_charset_same(cs, system_charset_info))
  {
    uint32 res_length;
    name= sql_strmake_with_convert(str, length, cs,
				   MAX_ALIAS_NAME, system_charset_info,
				   &res_length);
  }
  else
    name=sql_strmake(str, min(length,MAX_ALIAS_NAME));
unknown's avatar
unknown committed
191 192
}

unknown's avatar
unknown committed
193

194
/*
195 196 197
  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
198 199 200
*/

bool Item::eq(const Item *item, bool binary_cmp) const
unknown's avatar
unknown committed
201 202
{
  return type() == item->type() && name && item->name &&
203
    !my_strcasecmp(system_charset_info,name,item->name);
unknown's avatar
unknown committed
204 205
}

unknown's avatar
unknown committed
206

207 208 209 210 211
bool Item_string::eq(const Item *item, bool binary_cmp) const
{
  if (type() == item->type())
  {
    if (binary_cmp)
unknown's avatar
unknown committed
212
      return !stringcmp(&str_value, &item->str_value);
213
    return !sortcmp(&str_value, &item->str_value, collation.collation);
214 215 216 217 218
  }
  return 0;
}


unknown's avatar
unknown committed
219 220 221 222 223
/*
  Get the value of the function as a TIME structure.
  As a extra convenience the time structure is reset on error!
 */

224
bool Item::get_date(TIME *ltime,uint fuzzydate)
unknown's avatar
unknown committed
225 226
{
  char buff[40];
unknown's avatar
unknown committed
227
  String tmp(buff,sizeof(buff), &my_charset_bin),*res;
unknown's avatar
unknown committed
228
  if (!(res=val_str(&tmp)) ||
229 230
      str_to_TIME(res->ptr(),res->length(),ltime,fuzzydate) <= 
      TIMESTAMP_DATETIME_ERROR)
unknown's avatar
unknown committed
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
  {
    bzero((char*) ltime,sizeof(*ltime));
    return 1;
  }
  return 0;
}

/*
  Get time of first argument.
  As a extra convenience the time structure is reset on error!
 */

bool Item::get_time(TIME *ltime)
{
  char buff[40];
unknown's avatar
unknown committed
246
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
unknown's avatar
unknown committed
247
  if (!(res=val_str(&tmp)) ||
248
      str_to_time(res->ptr(),res->length(),ltime))
unknown's avatar
unknown committed
249 250 251 252 253 254 255
  {
    bzero((char*) ltime,sizeof(*ltime));
    return 1;
  }
  return 0;
}

256
CHARSET_INFO * Item::default_charset() 
257
{
unknown's avatar
unknown committed
258
  return current_thd->variables.collation_connection;
259 260
}

261
bool DTCollation::aggregate(DTCollation &dt)
262
{
263
  if (!my_charset_same(collation, dt.collation))
264
  {
265 266 267
    /* 
       We do allow to use binary strings (like BLOBS)
       together with character strings.
unknown's avatar
unknown committed
268 269
       Binaries have more precedance than a character
       string of the same derivation.
270
    */
271
    if (collation == &my_charset_bin)
272
    {
273 274 275 276
      if (derivation <= dt.derivation)
	; // Do nothing
      else
	set(dt);
277
    }
278
    else if (dt.collation == &my_charset_bin)
279
    {
280 281 282 283
      if (dt.derivation <= derivation)
        set(dt);
      else
       ; // Do nothing
284 285 286 287 288 289
    }
    else
    {
      set(0, DERIVATION_NONE);
      return 1; 
    }
290
  }
291
  else if (derivation < dt.derivation)
292
  {
293
    // Do nothing
294
  }
295
  else if (dt.derivation < derivation)
296
  {
297
    set(dt);
298
  }
299 300 301
  else
  { 
    if (collation == dt.collation)
302
    {
303 304 305 306 307
      // Do nothing
    }
    else 
    {
      if (derivation == DERIVATION_EXPLICIT)
308
      {
309 310
	set(0, DERIVATION_NONE);
	return 1;
311
      }
312 313 314
      CHARSET_INFO *bin= get_charset_by_csname(collation->csname, 
					       MY_CS_BINSORT,MYF(0));
      set(bin, DERIVATION_NONE);
315
    }
316 317 318 319
  }
  return 0;
}

unknown's avatar
unknown committed
320
Item_field::Item_field(Field *f)
321
  :Item_ident(NullS, f->table_name, f->field_name)
unknown's avatar
unknown committed
322 323
{
  set_field(f);
324
  collation.set(DERIVATION_IMPLICIT);
unknown's avatar
unknown committed
325
  fixed= 1;
unknown's avatar
unknown committed
326 327
}

328 329 330 331 332 333 334 335 336
Item_field::Item_field(THD *thd, Field *f)
  :Item_ident(NullS, thd->strdup(f->table_name), 
              thd->strdup(f->field_name))
{
  set_field(f);
  collation.set(DERIVATION_IMPLICIT);
  fixed= 1;
}

337
// Constructor need to process subselect with temporary tables (see Item)
338
Item_field::Item_field(THD *thd, Item_field *item)
339
  :Item_ident(thd, item),
340 341
   field(item->field),
   result_field(item->result_field)
342 343 344
{
  collation.set(DERIVATION_IMPLICIT);
}
unknown's avatar
unknown committed
345 346 347 348 349 350 351 352 353

void Item_field::set_field(Field *field_par)
{
  field=result_field=field_par;			// for easy coding with fields
  maybe_null=field->maybe_null();
  max_length=field_par->field_length;
  decimals= field->decimals();
  table_name=field_par->table_name;
  field_name=field_par->field_name;
354
  db_name=field_par->table->table_cache_key;
355
  unsigned_flag=test(field_par->flags & UNSIGNED_FLAG);
356
  collation.set(field_par->charset(), DERIVATION_IMPLICIT);
unknown's avatar
unknown committed
357 358 359 360 361
}

const char *Item_ident::full_name() const
{
  char *tmp;
362
  if (!table_name || !field_name)
unknown's avatar
unknown committed
363
    return field_name ? field_name : name ? name : "tmp_field";
unknown's avatar
unknown committed
364
  if (db_name && db_name[0])
unknown's avatar
unknown committed
365
  {
unknown's avatar
unknown committed
366 367
    tmp=(char*) sql_alloc((uint) strlen(db_name)+(uint) strlen(table_name)+
			  (uint) strlen(field_name)+3);
unknown's avatar
unknown committed
368 369 370 371
    strxmov(tmp,db_name,".",table_name,".",field_name,NullS);
  }
  else
  {
372 373 374 375 376 377 378 379
    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;
unknown's avatar
unknown committed
380 381 382 383 384 385 386
  }
  return tmp;
}

/* ARGSUSED */
String *Item_field::val_str(String *str)
{
387
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
388 389
  if ((null_value=field->is_null()))
    return 0;
390
  str->set_charset(str_value.charset());
unknown's avatar
unknown committed
391 392 393 394 395
  return field->val_str(str,&str_value);
}

double Item_field::val()
{
396
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
397 398 399 400 401 402 403
  if ((null_value=field->is_null()))
    return 0.0;
  return field->val_real();
}

longlong Item_field::val_int()
{
404
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
405 406 407 408 409 410 411 412 413 414
  if ((null_value=field->is_null()))
    return 0;
  return field->val_int();
}


String *Item_field::str_result(String *str)
{
  if ((null_value=result_field->is_null()))
    return 0;
415
  str->set_charset(str_value.charset());
unknown's avatar
unknown committed
416 417 418
  return result_field->val_str(str,&str_value);
}

419
bool Item_field::get_date(TIME *ltime,uint fuzzydate)
unknown's avatar
unknown committed
420 421 422 423 424 425 426 427 428
{
  if ((null_value=field->is_null()) || field->get_date(ltime,fuzzydate))
  {
    bzero((char*) ltime,sizeof(*ltime));
    return 1;
  }
  return 0;
}

429
bool Item_field::get_date_result(TIME *ltime,uint fuzzydate)
430 431 432 433 434 435 436 437 438 439
{
  if ((null_value=result_field->is_null()) ||
      result_field->get_date(ltime,fuzzydate))
  {
    bzero((char*) ltime,sizeof(*ltime));
    return 1;
  }
  return 0;
}

unknown's avatar
unknown committed
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
bool Item_field::get_time(TIME *ltime)
{
  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();
}

464

465
bool Item_field::eq(const Item *item, bool binary_cmp) const
unknown's avatar
unknown committed
466
{
467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
  if (item->type() != FIELD_ITEM)
    return 0;
  
  Item_field *item_field= (Item_field*) item;
  if (item_field->field)
    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) &&
	  (!item_field->table_name ||
	   (!my_strcasecmp(table_alias_charset, item_field->table_name,
			   table_name) &&
	    (!item_field->db_name ||
489 490
	     (item_field->db_name && !strcmp(item_field->db_name,
					     db_name))))));
unknown's avatar
unknown committed
491 492
}

493

unknown's avatar
unknown committed
494 495 496 497
table_map Item_field::used_tables() const
{
  if (field->table->const_table)
    return 0;					// const item
unknown's avatar
unknown committed
498
  return (depended_from ? OUTER_REF_TABLE_BIT : field->table->map);
unknown's avatar
unknown committed
499 500
}

501

502
Item *Item_field::get_tmp_table_item(THD *thd)
503
{
504
  Item_field *new_item= new Item_field(thd, this);
505 506 507 508
  if (new_item)
    new_item->field= new_item->result_field;
  return new_item;
}
unknown's avatar
unknown committed
509

510

unknown's avatar
unknown committed
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
/*
  Create an item from a string we KNOW points to a valid longlong/ulonglong
  end \0 terminated number string
*/

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;
}


unknown's avatar
unknown committed
527 528
String *Item_int::val_str(String *str)
{
unknown's avatar
unknown committed
529
  // following assert is redundant, because fixed=1 assigned in constructor
530
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
531
  str->set(value, &my_charset_bin);
unknown's avatar
unknown committed
532 533 534 535 536
  return str;
}

void Item_int::print(String *str)
{
unknown's avatar
unknown committed
537 538
  // my_charset_bin is good enough for numbers
  str_value.set(value, &my_charset_bin);
unknown's avatar
unknown committed
539
  str->append(str_value);
unknown's avatar
unknown committed
540 541
}

542

unknown's avatar
unknown committed
543 544 545 546 547 548 549
Item_uint::Item_uint(const char *str_arg, uint length):
  Item_int(str_arg, length)
{
  unsigned_flag= 1;
}


unknown's avatar
unknown committed
550 551
String *Item_uint::val_str(String *str)
{
unknown's avatar
unknown committed
552
  // following assert is redundant, because fixed=1 assigned in constructor
553
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
554
  str->set((ulonglong) value, &my_charset_bin);
unknown's avatar
unknown committed
555 556 557
  return str;
}

558

unknown's avatar
unknown committed
559 560
void Item_uint::print(String *str)
{
561
  // latin1 is good enough for numbers
unknown's avatar
unknown committed
562 563
  str_value.set((ulonglong) value, default_charset());
  str->append(str_value);
unknown's avatar
unknown committed
564 565
}

unknown's avatar
unknown committed
566 567 568

String *Item_real::val_str(String *str)
{
unknown's avatar
unknown committed
569
  // following assert is redundant, because fixed=1 assigned in constructor
570
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
571
  str->set(value,decimals,&my_charset_bin);
unknown's avatar
unknown committed
572 573 574
  return str;
}

575

unknown's avatar
unknown committed
576 577
void Item_string::print(String *str)
{
578 579
  str->append('_');
  str->append(collation.collation->csname);
unknown's avatar
unknown committed
580
  str->append('\'');
unknown's avatar
unknown committed
581
  str_value.print(str);
unknown's avatar
unknown committed
582 583 584
  str->append('\'');
}

585 586
bool Item_null::eq(const Item *item, bool binary_cmp) const
{ return item->type() == type(); }
587 588
double Item_null::val()
{
unknown's avatar
unknown committed
589 590
  // following assert is redundant, because fixed=1 assigned in constructor
  DBUG_ASSERT(fixed == 1);
591 592 593 594 595
  null_value=1;
  return 0.0;
}
longlong Item_null::val_int()
{
unknown's avatar
unknown committed
596 597
  // following assert is redundant, because fixed=1 assigned in constructor
  DBUG_ASSERT(fixed == 1);
598 599 600
  null_value=1;
  return 0;
}
unknown's avatar
unknown committed
601 602
/* ARGSUSED */
String *Item_null::val_str(String *str)
603
{
unknown's avatar
unknown committed
604 605
  // following assert is redundant, because fixed=1 assigned in constructor
  DBUG_ASSERT(fixed == 1);
606 607 608
  null_value=1;
  return 0;
}
unknown's avatar
unknown committed
609 610


611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
/*********************** Item_param related ******************************/

/* 
  Default function of Item_param::set_param_func, so in case
  of malformed packet the server won't SIGSEGV
*/

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

Item_param::Item_param(unsigned position) :
  value_is_set(FALSE),
  item_result_type(STRING_RESULT),
  item_type(STRING_ITEM),
  item_is_time(FALSE),
  long_data_supplied(FALSE),
  pos_in_query(position),
  set_param_func(default_set_param_func)
{
  name= (char*) "?";
636 637 638 639 640 641
  /* 
    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;
642 643
}

unknown's avatar
unknown committed
644
void Item_param::set_null()
645 646
{
  DBUG_ENTER("Item_param::set_null");
647 648
  /* These are cleared after each execution by reset() method */
  null_value= value_is_set= 1;
649
  max_length= 0;
650
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
651 652 653
}

void Item_param::set_int(longlong i)
654 655 656 657
{
  DBUG_ENTER("Item_param::set_int");
  int_value= (longlong)i;
  item_type= INT_ITEM;
658
  value_is_set= 1;
659
  maybe_null= 0;
660
  max_length= 11;
661 662
  DBUG_PRINT("info", ("integer: %lld", int_value));
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
663 664
}

665
void Item_param::set_double(double value)
666 667
{
  DBUG_ENTER("Item_param::set_double");
unknown's avatar
unknown committed
668
  real_value=value;
669
  item_type= REAL_ITEM;
670
  value_is_set= 1;
671
  maybe_null= 0;
672 673
  decimals= NOT_FIXED_DEC;
  max_length= DBL_DIG + 8;;
674 675
  DBUG_PRINT("info", ("double: %lg", real_value));
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
676 677 678
}


unknown's avatar
unknown committed
679
void Item_param::set_value(const char *str, uint length, CHARSET_INFO *ci)
680 681
{
  DBUG_ENTER("Item_param::set_value");
unknown's avatar
unknown committed
682
  str_value.copy(str,length,ci);
683
  item_type= STRING_ITEM;
684
  value_is_set= 1;
685
  maybe_null= 0;
686
  max_length= length;
687 688
  DBUG_PRINT("info", ("string: %s", str_value.ptr()));
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
689 690
}

691

692 693 694 695 696 697 698 699 700 701 702 703
void Item_param::set_time(TIME *tm, timestamp_type type)
{ 
  ltime.year= tm->year;
  ltime.month= tm->month;
  ltime.day= tm->day;
  
  ltime.hour= tm->hour;
  ltime.minute= tm->minute;
  ltime.second= tm->second; 

  ltime.second_part= tm->second_part;

unknown's avatar
unknown committed
704 705
  ltime.neg= tm->neg;

706 707
  ltime.time_type= type;
  
unknown's avatar
unknown committed
708
  item_is_time= TRUE;
709
  item_type= STRING_ITEM;
710
  value_is_set= 1;
711
  maybe_null= 0;
712 713 714 715 716 717 718 719 720 721 722 723 724 725
  switch(type)
  {
  case TIMESTAMP_DATE:
    max_length= 10;
    break;
  case TIMESTAMP_DATETIME:
    max_length= 19;
    break;
  case TIMESTAMP_TIME:
    max_length= 8;
    break;
  default:
    DBUG_ASSERT(0); // it should be impossible
  }
726 727 728
}


unknown's avatar
unknown committed
729 730 731 732
void Item_param::set_longdata(const char *str, ulong length)
{  
  str_value.append(str,length);
  long_data_supplied= 1;
733
  value_is_set= 1;
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754
  maybe_null= 0;
}


/*
    Resets parameter after execution.
  
  SYNOPSIS
     Item_param::reset()
 
  NOTES
    We clear null_value here instead of setting it in set_* methods, 
    because we want more easily handle case for long data.
*/

void Item_param::reset()
{  
  str_value.set("", 0, &my_charset_bin);
  value_is_set= long_data_supplied= 0;
  maybe_null= 1;
  null_value= 0;
unknown's avatar
unknown committed
755 756 757
}


unknown's avatar
unknown committed
758
int Item_param::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
759
{
unknown's avatar
unknown committed
760
  DBUG_ASSERT(current_thd->command == COM_EXECUTE);
unknown's avatar
unknown committed
761
  
unknown's avatar
unknown committed
762
  if (null_value)
763
    return (int) set_field_to_null(field);   
unknown's avatar
unknown committed
764 765 766 767 768
    
  field->set_notnull();
  if (item_result_type == INT_RESULT)
  {
    longlong nr=val_int();
769
    return field->store(nr);
unknown's avatar
unknown committed
770 771 772 773
  }
  if (item_result_type == REAL_RESULT)
  {
    double nr=val();    
774
    return field->store(nr); 
775 776 777 778 779
  }  
  if (item_is_time)
  {
    field->store_time(&ltime, ltime.time_type);
    return 0;
unknown's avatar
unknown committed
780
  }
unknown's avatar
unknown committed
781
  String *result=val_str(&str_value);
unknown's avatar
unknown committed
782
  return field->store(result->ptr(),result->length(),field->charset());
unknown's avatar
unknown committed
783 784
}

785 786 787 788 789
bool Item_param::get_time(TIME *res)
{
  *res=ltime;
  return 0;
}
790

unknown's avatar
unknown committed
791 792
double Item_param::val() 
{
793
  DBUG_ASSERT(value_is_set == 1);
794
  int err;
795 796
  if (null_value)
    return 0.0;
797
  switch (item_result_type) {
unknown's avatar
unknown committed
798
  case STRING_RESULT:
799
    return (double) my_strntod(str_value.charset(), (char*) str_value.ptr(),
800
			       str_value.length(), (char**) 0, &err); 
unknown's avatar
unknown committed
801 802 803 804 805 806 807
  case INT_RESULT:
    return (double)int_value;
  default:
    return real_value;
  }
} 

808

unknown's avatar
unknown committed
809 810
longlong Item_param::val_int() 
{ 
811
  DBUG_ASSERT(value_is_set == 1);
812
  int err;
813 814
  if (null_value)
    return 0;
815
  switch (item_result_type) {
unknown's avatar
unknown committed
816
  case STRING_RESULT:
817 818 819
    return my_strntoll(str_value.charset(),
		       str_value.ptr(),str_value.length(),10,
		       (char**) 0,&err);
unknown's avatar
unknown committed
820 821 822 823 824 825 826
  case REAL_RESULT:
    return (longlong) (real_value+(real_value > 0 ? 0.5 : -0.5));
  default:
    return int_value;
  }
}

827

unknown's avatar
unknown committed
828 829
String *Item_param::val_str(String* str) 
{ 
830
  DBUG_ASSERT(value_is_set == 1);
unknown's avatar
unknown committed
831 832
  if (null_value)
    return NULL;
833
  switch (item_result_type) {
unknown's avatar
unknown committed
834
  case INT_RESULT:
unknown's avatar
unknown committed
835
    str->set(int_value, &my_charset_bin);
unknown's avatar
unknown committed
836 837
    return str;
  case REAL_RESULT:
unknown's avatar
unknown committed
838
    str->set(real_value, 2, &my_charset_bin);
unknown's avatar
unknown committed
839 840 841 842 843
    return str;
  default:
    return (String*) &str_value;
  }
}
844 845 846 847 848 849 850

/*
  Return Param item values in string format, for generating the dynamic 
  query used in update/binary logs
*/

String *Item_param::query_val_str(String* str) 
851
{
852
  DBUG_ASSERT(value_is_set == 1);
853 854 855
  switch (item_result_type) {
  case INT_RESULT:
  case REAL_RESULT:
856
    return val_str(str);
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885
  default:
    str->set("'", 1, default_charset());
    
    if (!item_is_time)
    {
      str->append(str_value);
      const char *from= str->ptr(); 
      uint32 length= 1;
      
      // Escape misc cases
      char *to= (char *)from, *end= (char *)to+str->length(); 
      for (to++; to != end ; length++, to++)
      {
        switch(*to) {
          case '\'':
          case '"':  
          case '\r':
          case '\n':
          case '\\': // TODO: Add remaining ..
            str->replace(length,0,"\\",1); 
            to++; end++; length++;
            break;
          default:     
            break;
        }
      }
    }
    else
    {
886 887
      char buff[40];
      String tmp(buff,sizeof(buff), &my_charset_bin);
888 889
      
      switch (ltime.time_type)  {
890 891 892 893 894 895 896 897 898 899 900 901 902
      case TIMESTAMP_NONE:
      case TIMESTAMP_DATETIME_ERROR:
	tmp.length(0);				// Should never happen
	break;
      case TIMESTAMP_DATE:
	make_date((DATE_TIME_FORMAT*) 0, &ltime, &tmp);
	break;
      case TIMESTAMP_DATETIME:
	make_datetime((DATE_TIME_FORMAT*) 0, &ltime, &tmp);
	break;
      case TIMESTAMP_TIME:
	make_time((DATE_TIME_FORMAT*) 0, &ltime, &tmp);
	break;
903
      }
904
      str->append(tmp);
905
    }
906
    str->append('\'');
907 908 909
  }
  return str;
}
unknown's avatar
unknown committed
910 911
/* End of Item_param related */

912

unknown's avatar
unknown committed
913 914 915 916 917 918 919 920 921 922 923
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)
{
924
  // Item_copy_string is used without fix_fields call
unknown's avatar
unknown committed
925 926 927 928 929
  if (null_value)
    return (String*) 0;
  return &str_value;
}

unknown's avatar
unknown committed
930 931 932 933 934 935 936 937 938 939

int Item_copy_string::save_in_field(Field *field, bool no_conversions)
{
  if (null_value)
    return set_field_to_null(field);
  field->set_notnull();
  return field->store(str_value.ptr(),str_value.length(),
		      collation.collation);
}

unknown's avatar
unknown committed
940
/*
941
  Functions to convert item to field (for send_fields)
unknown's avatar
unknown committed
942 943 944 945
*/

/* ARGSUSED */
bool Item::fix_fields(THD *thd,
unknown's avatar
unknown committed
946 947
		      struct st_table_list *list,
		      Item ** ref)
unknown's avatar
unknown committed
948
{
949 950

  // We do not check fields which are fixed during construction
unknown's avatar
unknown committed
951
  DBUG_ASSERT(fixed == 0 || basic_const_item());
952
  fixed= 1;
unknown's avatar
unknown committed
953 954 955
  return 0;
}

956 957
double Item_ref_null_helper::val()
{
958
  DBUG_ASSERT(fixed == 1);
959
  double tmp= (*ref)->val_result();
unknown's avatar
unknown committed
960
  owner->was_null|= null_value= (*ref)->null_value;
961 962
  return tmp;
}
963 964


965 966
longlong Item_ref_null_helper::val_int()
{
967
  DBUG_ASSERT(fixed == 1);
968
  longlong tmp= (*ref)->val_int_result();
unknown's avatar
unknown committed
969
  owner->was_null|= null_value= (*ref)->null_value;
970 971
  return tmp;
}
972 973


974 975
String* Item_ref_null_helper::val_str(String* s)
{
976
  DBUG_ASSERT(fixed == 1);
977
  String* tmp= (*ref)->str_result(s);
unknown's avatar
unknown committed
978
  owner->was_null|= null_value= (*ref)->null_value;
979 980
  return tmp;
}
981 982


983
bool Item_ref_null_helper::get_date(TIME *ltime, uint fuzzydate)
984 985 986
{  
  return (owner->was_null|= null_value= (*ref)->get_date(ltime, fuzzydate));
}
unknown's avatar
unknown committed
987

unknown's avatar
unknown committed
988 989 990 991 992 993

/*
  Mark item and SELECT_LEXs as dependent if it is not outer resolving

  SYNOPSIS
    mark_as_dependent()
994
    thd - thread handler
unknown's avatar
unknown committed
995 996 997 998 999
    last - select from which current item depend
    current  - current select
    item - item which should be marked
*/

1000
static void mark_as_dependent(THD *thd, SELECT_LEX *last, SELECT_LEX *current,
unknown's avatar
unknown committed
1001 1002
			      Item_ident *item)
{
unknown's avatar
unknown committed
1003 1004 1005
  // store pointer on SELECT_LEX from wich item is dependent
  item->depended_from= last;
  current->mark_as_dependent(last);
1006
  if (thd->lex->describe & DESCRIBE_EXTENDED)
1007 1008 1009 1010 1011 1012 1013 1014 1015 1016
  {
    char warn_buff[MYSQL_ERRMSG_SIZE];
    sprintf(warn_buff, ER(ER_WARN_FIELD_RESOLVED),
	    (item->db_name?item->db_name:""), (item->db_name?".":""),
	    (item->table_name?item->table_name:""), (item->table_name?".":""),
	    item->field_name,
	    current->select_number, last->select_number);
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		 ER_WARN_FIELD_RESOLVED, warn_buff);
  }
unknown's avatar
unknown committed
1017 1018 1019
}


unknown's avatar
unknown committed
1020
bool Item_field::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
unknown's avatar
unknown committed
1021
{
unknown's avatar
unknown committed
1022
  DBUG_ASSERT(fixed == 0);
1023
  if (!field)					// If field is not checked
unknown's avatar
unknown committed
1024
  {
1025
    TABLE_LIST *where= 0;
1026
    bool upward_lookup= 0;
1027
    Field *tmp= (Field *)not_found_field;
unknown's avatar
unknown committed
1028
    if ((tmp= find_field_in_tables(thd, this, tables, &where, 0)) ==
1029
	not_found_field)
1030 1031
    {
      /*
1032
	We can't find table field in table list of current select,
1033
	consequently we have to find it in outer subselect(s).
1034 1035 1036
	We can't join lists of outer & current select, because of scope
	of view rules. For example if both tables (outer & current) have
	field 'field' it is not mistake to refer to this field without
1037 1038 1039
	mention of table name, but if we join tables in one list it will
	cause error ER_NON_UNIQ_ERROR in find_field_in_tables.
      */
unknown's avatar
unknown committed
1040
      SELECT_LEX *last= 0;
unknown's avatar
unknown committed
1041 1042 1043
#ifdef EMBEDDED_LIBRARY
      thd->net.last_errno= 0;
#endif
1044
      TABLE_LIST *table_list;
1045
      Item **refer= (Item **)not_found_item;
1046
      uint counter;
1047
      // Prevent using outer fields in subselects, that is not supported now
1048
      SELECT_LEX *cursel= (SELECT_LEX *) thd->lex->current_select;
unknown's avatar
unknown committed
1049
      if (cursel->master_unit()->first_select()->linkage != DERIVED_TABLE_TYPE)
1050 1051 1052
      {
	SELECT_LEX_UNIT *prev_unit= cursel->master_unit();
	for (SELECT_LEX *sl= prev_unit->outer_select();
1053
	     sl;
1054
	     sl= (prev_unit= sl->master_unit())->outer_select())
1055
	{
1056
	  upward_lookup= 1;
1057
	  table_list= (last= sl)->get_table_list();
1058
	  if (sl->resolve_mode == SELECT_LEX::INSERT_MODE && table_list)
1059 1060 1061 1062
	  {
	    // it is primary INSERT st_select_lex => skip first table resolving
	    table_list= table_list->next;
	  }
unknown's avatar
unknown committed
1063 1064

	  Item_subselect *prev_subselect_item= prev_unit->item;
1065
	  if ((tmp= find_field_in_tables(thd, this,
1066
					 table_list, &where,
1067
					 0)) != not_found_field)
1068
	  {
unknown's avatar
unknown committed
1069 1070
	    if (!tmp)
	      return -1;
unknown's avatar
unknown committed
1071 1072
	    prev_subselect_item->used_tables_cache|= tmp->table->map;
	    prev_subselect_item->const_item_cache= 0;
1073
	    break;
1074
	  }
1075
	  if (sl->resolve_mode == SELECT_LEX::SELECT_MODE &&
1076 1077
	      (refer= find_item_in_list(this, sl->item_list, &counter,
					 REPORT_EXCEPT_NOT_FOUND)) !=
1078
	       (Item **) not_found_item)
1079 1080 1081
	  {
	    if (*refer && (*refer)->fixed) // Avoid crash in case of error
	    {
unknown's avatar
unknown committed
1082 1083
	      prev_subselect_item->used_tables_cache|= (*refer)->used_tables();
	      prev_subselect_item->const_item_cache&= (*refer)->const_item();
1084
	    }
1085
	    break;
1086 1087 1088
	  }

	  // Reference is not found => depend from outer (or just error)
unknown's avatar
unknown committed
1089 1090
	  prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
	  prev_subselect_item->const_item_cache= 0;
1091

1092 1093
	  if (sl->master_unit()->first_select()->linkage ==
	      DERIVED_TABLE_TYPE)
1094
	    break; // do not look over derived table
1095
	}
1096
      }
1097
      if (!tmp)
1098
	return -1;
1099 1100 1101
      else if (!refer)
	return 1;
      else if (tmp == not_found_field && refer == (Item **)not_found_item)
unknown's avatar
unknown committed
1102
      {
1103
	if (upward_lookup)
unknown's avatar
unknown committed
1104
	{
1105 1106 1107
	  // We can't say exactly what absend table or field
	  my_printf_error(ER_BAD_FIELD_ERROR, ER(ER_BAD_FIELD_ERROR), MYF(0),
			  full_name(), thd->where);
unknown's avatar
unknown committed
1108
	}
1109
	else
unknown's avatar
unknown committed
1110
	{
1111 1112
	  // Call to report error
	  find_field_in_tables(thd, this, tables, &where, 1);
unknown's avatar
unknown committed
1113
	}
unknown's avatar
unknown committed
1114 1115
	return -1;
      }
1116 1117
      else if (refer != (Item **)not_found_item)
      {
1118 1119 1120 1121 1122 1123 1124
	if (!(*refer)->fixed)
	{
	  my_error(ER_ILLEGAL_REFERENCE, MYF(0), name,
		   "forward reference in item list");
	  return -1;
	}

unknown's avatar
unknown committed
1125 1126
	Item_ref *rf;
	*ref= rf= new Item_ref(last->ref_pointer_array + counter,
unknown's avatar
unknown committed
1127
			       ref,
unknown's avatar
unknown committed
1128 1129
			       (char *)table_name,
			       (char *)field_name);
1130
	register_item_tree_changing(ref);
unknown's avatar
unknown committed
1131
	if (!rf)
1132
	  return 1;
1133 1134 1135 1136
	/*
	  rf is Item_ref => never substitute other items (in this case)
	  during fix_fields() => we can use rf after fix_fields()
	*/
unknown's avatar
unknown committed
1137
	if (rf->fix_fields(thd, tables, ref) || rf->check_cols(1))
unknown's avatar
unknown committed
1138
	  return 1;
unknown's avatar
unknown committed
1139

1140
	mark_as_dependent(thd, last, cursel, rf);
1141 1142
	return 0;
      }
1143
      else
unknown's avatar
unknown committed
1144
      {
1145
	mark_as_dependent(thd, last, cursel, this);
unknown's avatar
unknown committed
1146
	if (last->having_fix_field)
1147 1148
	{
	  Item_ref *rf;
1149
	  *ref= rf= new Item_ref(ref, *ref,
unknown's avatar
unknown committed
1150
				 (where->db[0]?where->db:0), 
1151 1152 1153 1154
				 (char *)where->alias,
				 (char *)field_name);
	  if (!rf)
	    return 1;
1155 1156 1157 1158
	  /*
	    rf is Item_ref => never substitute other items (in this case)
	    during fix_fields() => we can use rf after fix_fields()
	  */
unknown's avatar
unknown committed
1159
	  return rf->fix_fields(thd, tables, ref) ||  rf->check_cols(1);
1160
	}
unknown's avatar
unknown committed
1161
      }
1162
    }
1163 1164 1165
    else if (!tmp)
      return -1;

unknown's avatar
unknown committed
1166 1167
    set_field(tmp);
  }
unknown's avatar
unknown committed
1168
  else if (thd->set_query_id && field->query_id != thd->query_id)
1169 1170 1171 1172 1173
  {
    /* We only come here in unions */
    TABLE *table=field->table;
    field->query_id=thd->query_id;
    table->used_fields++;
1174
    table->used_keys.intersect(field->part_of_key);
1175
  }
1176
  fixed= 1;
unknown's avatar
unknown committed
1177 1178 1179
  return 0;
}

unknown's avatar
unknown committed
1180 1181
void Item_field::cleanup()
{
unknown's avatar
unknown committed
1182
  DBUG_ENTER("Item_field::cleanup");
unknown's avatar
unknown committed
1183
  Item_ident::cleanup();
1184 1185 1186 1187 1188
  /*
    Even if this object was created by direct link to field in setup_wild()
    it will be linked correctly next tyme by name of field and table alias.
    I.e. we can drop 'field'.
   */
1189
  field= result_field= 0;
unknown's avatar
unknown committed
1190
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1191
}
unknown's avatar
unknown committed
1192 1193 1194

void Item::init_make_field(Send_field *tmp_field,
			   enum enum_field_types field_type)
1195
{
1196
  char *empty_name= (char*) "";
1197
  tmp_field->db_name=		empty_name;
1198 1199 1200 1201
  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;
1202
  tmp_field->charsetnr=         collation.collation->number;
unknown's avatar
unknown committed
1203 1204 1205 1206
  tmp_field->flags=maybe_null ? 0 : NOT_NULL_FLAG;
  tmp_field->type=field_type;
  tmp_field->length=max_length;
  tmp_field->decimals=decimals;
1207 1208
  if (unsigned_flag)
    tmp_field->flags |= UNSIGNED_FLAG;
unknown's avatar
unknown committed
1209 1210
}

1211
void Item::make_field(Send_field *tmp_field)
unknown's avatar
unknown committed
1212
{
1213
  init_make_field(tmp_field, field_type());
unknown's avatar
unknown committed
1214 1215 1216
}


1217 1218 1219 1220 1221
void Item_empty_string::make_field(Send_field *tmp_field)
{
  init_make_field(tmp_field,FIELD_TYPE_VAR_STRING);
}

unknown's avatar
unknown committed
1222

1223
enum_field_types Item::field_type() const
unknown's avatar
unknown committed
1224
{
1225 1226 1227
  return ((result_type() == STRING_RESULT) ? FIELD_TYPE_VAR_STRING :
	  (result_type() == INT_RESULT) ? FIELD_TYPE_LONGLONG :
	  FIELD_TYPE_DOUBLE);
unknown's avatar
unknown committed
1228 1229
}

1230

1231 1232
Field *Item::tmp_table_field_from_field_type(TABLE *table)
{
1233 1234 1235 1236 1237 1238
  /*
    The field functions defines a field to be not null if null_ptr is not 0
  */
  uchar *null_ptr= maybe_null ? (uchar*) "" : 0;

  switch (field_type()) {
1239
  case MYSQL_TYPE_DECIMAL:
1240 1241
    return new Field_decimal((char*) 0, max_length, null_ptr, 0, Field::NONE,
			     name, table, decimals, 0, unsigned_flag);
1242
  case MYSQL_TYPE_TINY:
1243 1244
    return new Field_tiny((char*) 0, max_length, null_ptr, 0, Field::NONE,
			  name, table, 0, unsigned_flag);
1245
  case MYSQL_TYPE_SHORT:
1246 1247
    return new Field_short((char*) 0, max_length, null_ptr, 0, Field::NONE,
			   name, table, 0, unsigned_flag);
1248
  case MYSQL_TYPE_LONG:
1249 1250
    return new Field_long((char*) 0, max_length, null_ptr, 0, Field::NONE,
			  name, table, 0, unsigned_flag);
1251 1252
#ifdef HAVE_LONG_LONG
  case MYSQL_TYPE_LONGLONG:
1253 1254
    return new Field_longlong((char*) 0, max_length, null_ptr, 0, Field::NONE,
			      name, table, 0, unsigned_flag);
1255
#endif
1256 1257 1258 1259 1260 1261 1262 1263 1264
  case MYSQL_TYPE_FLOAT:
    return new Field_float((char*) 0, max_length, null_ptr, 0, Field::NONE,
			   name, table, decimals, 0, unsigned_flag);
  case MYSQL_TYPE_DOUBLE:
    return new Field_double((char*) 0, max_length, null_ptr, 0, Field::NONE,
			    name, table, decimals, 0, unsigned_flag);
  case MYSQL_TYPE_NULL:
    return new Field_null((char*) 0, max_length, Field::NONE,
			  name, table, &my_charset_bin);
1265 1266
  case MYSQL_TYPE_NEWDATE:
  case MYSQL_TYPE_INT24:
1267 1268
    return new Field_medium((char*) 0, max_length, null_ptr, 0, Field::NONE,
			    name, table, 0, unsigned_flag);
1269 1270 1271 1272 1273 1274 1275 1276
  case MYSQL_TYPE_DATE:
    return new Field_date(maybe_null, name, table, &my_charset_bin);
  case MYSQL_TYPE_TIME:
    return new Field_time(maybe_null, name, table, &my_charset_bin);
  case MYSQL_TYPE_TIMESTAMP:
  case MYSQL_TYPE_DATETIME:
    return new Field_datetime(maybe_null, name, table, &my_charset_bin);
  case MYSQL_TYPE_YEAR:
1277 1278 1279 1280 1281 1282
    return new Field_year((char*) 0, max_length, null_ptr, 0, Field::NONE,
			  name, table);
  default:
    /* This case should never be choosen */
    DBUG_ASSERT(0);
    /* If something goes awfully wrong, it's better to get a string than die */
1283 1284
  case MYSQL_TYPE_ENUM:
  case MYSQL_TYPE_SET:
1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
  case MYSQL_TYPE_VAR_STRING:
    if (max_length > 255)
      break;					// If blob
    return new Field_varstring(max_length, maybe_null, name, table,
			       collation.collation);
  case MYSQL_TYPE_STRING:
    if (max_length > 255)			// If blob
      break;
    return new Field_string(max_length, maybe_null, name, table,
			    collation.collation);
1295 1296 1297 1298 1299
  case MYSQL_TYPE_TINY_BLOB:
  case MYSQL_TYPE_MEDIUM_BLOB:
  case MYSQL_TYPE_LONG_BLOB:
  case MYSQL_TYPE_BLOB:
  case MYSQL_TYPE_GEOMETRY:
1300
    break;					// Blob handled outside of case
1301
  }
1302 1303 1304 1305

  /* blob is special as it's generated for both blobs and long strings */
  return new Field_blob(max_length, maybe_null, name, table,
			collation.collation);
1306 1307
}

1308

1309 1310
/* ARGSUSED */
void Item_field::make_field(Send_field *tmp_field)
unknown's avatar
unknown committed
1311
{
1312
  field->make_field(tmp_field);
1313
  DBUG_ASSERT(tmp_field->table_name);
1314 1315
  if (name)
    tmp_field->col_name=name;			// Use user supplied name
unknown's avatar
unknown committed
1316 1317
}

1318

unknown's avatar
unknown committed
1319
/*
1320
  Set a field:s value from a item
unknown's avatar
unknown committed
1321 1322 1323 1324 1325 1326 1327
*/

void Item_field::save_org_in_field(Field *to)
{
  if (field->is_null())
  {
    null_value=1;
1328
    set_field_to_null_with_conversions(to, 1);
unknown's avatar
unknown committed
1329 1330 1331 1332 1333 1334 1335 1336 1337
  }
  else
  {
    to->set_notnull();
    field_conv(to,field);
    null_value=0;
  }
}

unknown's avatar
unknown committed
1338
int Item_field::save_in_field(Field *to, bool no_conversions)
unknown's avatar
unknown committed
1339 1340 1341 1342
{
  if (result_field->is_null())
  {
    null_value=1;
1343
    return set_field_to_null_with_conversions(to, no_conversions);
unknown's avatar
unknown committed
1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
  }
  else
  {
    to->set_notnull();
    field_conv(to,result_field);
    null_value=0;
  }
  return 0;
}

1354

unknown's avatar
unknown committed
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370
/*
  Store null in field

  SYNOPSIS
    save_in_field()
    field		Field where we want to store NULL

  DESCRIPTION
    This is used on INSERT.
    Allow NULL to be inserted in timestamp and auto_increment values

  RETURN VALUES
    0	 ok
    1	 Field doesn't support NULL values and can't handle 'field = NULL'
*/   

unknown's avatar
unknown committed
1371
int Item_null::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
1372
{
1373
  return set_field_to_null_with_conversions(field, no_conversions);
unknown's avatar
unknown committed
1374 1375 1376
}


1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
/*
  Store null in field

  SYNOPSIS
    save_safe_in_field()
    field		Field where we want to store NULL

  RETURN VALUES
    0	 ok
    1	 Field doesn't support NULL values
*/   

unknown's avatar
unknown committed
1389
int Item_null::save_safe_in_field(Field *field)
unknown's avatar
unknown committed
1390 1391 1392 1393 1394
{
  return set_field_to_null(field);
}


unknown's avatar
unknown committed
1395
int Item::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
1396
{
1397
  int error;
unknown's avatar
unknown committed
1398 1399 1400 1401 1402
  if (result_type() == STRING_RESULT ||
      result_type() == REAL_RESULT &&
      field->result_type() == STRING_RESULT)
  {
    String *result;
1403
    CHARSET_INFO *cs= collation.collation;
unknown's avatar
unknown committed
1404
    char buff[MAX_FIELD_WIDTH];		// Alloc buffer for small columns
unknown's avatar
unknown committed
1405 1406
    str_value.set_quick(buff, sizeof(buff), cs);
    result=val_str(&str_value);
unknown's avatar
unknown committed
1407
    if (null_value)
1408
    {
unknown's avatar
unknown committed
1409
      str_value.set_quick(0, 0, cs);
1410
      return set_field_to_null_with_conversions(field, no_conversions);
1411
    }
unknown's avatar
unknown committed
1412
    field->set_notnull();
1413
    error=field->store(result->ptr(),result->length(),cs);
1414
    str_value.set_quick(0, 0, cs);
unknown's avatar
unknown committed
1415 1416 1417 1418 1419 1420 1421
  }
  else if (result_type() == REAL_RESULT)
  {
    double nr=val();
    if (null_value)
      return set_field_to_null(field);
    field->set_notnull();
1422
    error=field->store(nr);
unknown's avatar
unknown committed
1423 1424 1425 1426 1427
  }
  else
  {
    longlong nr=val_int();
    if (null_value)
1428
      return set_field_to_null_with_conversions(field, no_conversions);
unknown's avatar
unknown committed
1429
    field->set_notnull();
1430
    error=field->store(nr);
unknown's avatar
unknown committed
1431
  }
unknown's avatar
unknown committed
1432
  return error;
unknown's avatar
unknown committed
1433 1434
}

1435

unknown's avatar
unknown committed
1436
int Item_string::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
1437 1438 1439 1440 1441 1442
{
  String *result;
  result=val_str(&str_value);
  if (null_value)
    return set_field_to_null(field);
  field->set_notnull();
unknown's avatar
unknown committed
1443
  return field->store(result->ptr(),result->length(),collation.collation);
unknown's avatar
unknown committed
1444 1445
}

unknown's avatar
unknown committed
1446
int Item_uint::save_in_field(Field *field, bool no_conversions)
1447
{
1448 1449 1450 1451
  /*
    TODO: To be fixed when wen have a
    field->store(longlong, unsigned_flag) method 
  */
unknown's avatar
unknown committed
1452
  return Item_int::save_in_field(field, no_conversions);
1453 1454
}

unknown's avatar
unknown committed
1455 1456

int Item_int::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
1457 1458 1459 1460 1461
{
  longlong nr=val_int();
  if (null_value)
    return set_field_to_null(field);
  field->set_notnull();
unknown's avatar
unknown committed
1462
  return field->store(nr);
unknown's avatar
unknown committed
1463 1464
}

unknown's avatar
unknown committed
1465 1466 1467 1468
Item_num *Item_uint::neg()
{
  return new Item_real(name, - ((double) value), 0, max_length);
}
unknown's avatar
unknown committed
1469 1470

int Item_real::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
1471 1472 1473 1474 1475
{
  double nr=val();
  if (null_value)
    return set_field_to_null(field);
  field->set_notnull();
unknown's avatar
unknown committed
1476
  return field->store(nr);
unknown's avatar
unknown committed
1477 1478 1479 1480 1481 1482 1483 1484
}

/****************************************************************************
** varbinary item
** In string context this is a binary string
** In number context this is a longlong value.
****************************************************************************/

unknown's avatar
unknown committed
1485
inline uint char_val(char X)
unknown's avatar
unknown committed
1486 1487 1488 1489 1490 1491
{
  return (uint) (X >= '0' && X <= '9' ? X-'0' :
		 X >= 'A' && X <= 'Z' ? X-'A'+10 :
		 X-'a'+10);
}

1492

1493
Item_varbinary::Item_varbinary(const char *str, uint str_length)
unknown's avatar
unknown committed
1494 1495 1496 1497 1498 1499
{
  name=(char*) str-2;				// Lex makes this start with 0x
  max_length=(str_length+1)/2;
  char *ptr=(char*) sql_alloc(max_length+1);
  if (!ptr)
    return;
unknown's avatar
unknown committed
1500
  str_value.set(ptr,max_length,&my_charset_bin);
unknown's avatar
unknown committed
1501 1502 1503 1504 1505 1506 1507 1508 1509
  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
1510
  collation.set(&my_charset_bin, DERIVATION_COERCIBLE);
unknown's avatar
unknown committed
1511
  fixed= 1;
unknown's avatar
unknown committed
1512 1513 1514 1515
}

longlong Item_varbinary::val_int()
{
unknown's avatar
unknown committed
1516
  // following assert is redundant, because fixed=1 assigned in constructor
1517
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1518 1519 1520 1521 1522 1523 1524 1525 1526 1527
  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;
}


unknown's avatar
unknown committed
1528
int Item_varbinary::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
1529
{
1530
  int error;
unknown's avatar
unknown committed
1531 1532 1533
  field->set_notnull();
  if (field->result_type() == STRING_RESULT)
  {
1534
    error=field->store(str_value.ptr(),str_value.length(),collation.collation);
unknown's avatar
unknown committed
1535 1536 1537 1538
  }
  else
  {
    longlong nr=val_int();
1539
    error=field->store(nr);
unknown's avatar
unknown committed
1540
  }
unknown's avatar
unknown committed
1541
  return error;
unknown's avatar
unknown committed
1542 1543 1544
}


1545 1546 1547 1548 1549
/*
  Pack data in buffer for sending
*/

bool Item_null::send(Protocol *protocol, String *packet)
unknown's avatar
unknown committed
1550
{
1551
  return protocol->store_null();
unknown's avatar
unknown committed
1552 1553 1554
}

/*
1555
  This is only called from items that is not of type item_field
unknown's avatar
unknown committed
1556 1557
*/

1558
bool Item::send(Protocol *protocol, String *buffer)
unknown's avatar
unknown committed
1559
{
1560 1561 1562 1563 1564 1565
  bool result;
  enum_field_types type;
  LINT_INIT(result);

  switch ((type=field_type())) {
  default:
1566 1567 1568 1569 1570 1571 1572 1573 1574
  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:
1575 1576 1577 1578 1579
  case MYSQL_TYPE_STRING:
  case MYSQL_TYPE_VAR_STRING:
  {
    String *res;
    if ((res=val_str(buffer)))
1580
      result= protocol->store(res->ptr(),res->length(),res->charset());
1581 1582 1583 1584
    break;
  }
  case MYSQL_TYPE_TINY:
  {
unknown's avatar
unknown committed
1585
    longlong nr;  
1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
    nr= val_int();
    if (!null_value)
      result= protocol->store_tiny(nr);
    break;
  }
  case MYSQL_TYPE_SHORT:
  {
    longlong nr;
    nr= val_int();
    if (!null_value)
      result= protocol->store_short(nr);
    break;
  }
1599
  case MYSQL_TYPE_INT24:
1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
  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;
  }
unknown's avatar
unknown committed
1616 1617 1618
  case MYSQL_TYPE_FLOAT:
  {
    float nr;
unknown's avatar
unknown committed
1619
    nr= (float) val();
unknown's avatar
unknown committed
1620 1621 1622 1623
    if (!null_value)
      result= protocol->store(nr, decimals, buffer);
    break;
  }
1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
  case MYSQL_TYPE_DOUBLE:
  {
    double nr;
    nr= val();
    if (!null_value)
      result= protocol->store(nr, decimals, buffer);
    break;
  }
  case MYSQL_TYPE_DATETIME:
  case MYSQL_TYPE_DATE:
1634
  case MYSQL_TYPE_TIMESTAMP:
1635 1636
  {
    TIME tm;
1637
    get_date(&tm, TIME_FUZZY_DATE);
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658
    if (!null_value)
    {
      if (type == MYSQL_TYPE_DATE)
	return protocol->store_date(&tm);
      else
	result= protocol->store(&tm);
    }
    break;
  }
  case MYSQL_TYPE_TIME:
  {
    TIME tm;
    get_time(&tm);
    if (!null_value)
      result= protocol->store_time(&tm);
    break;
  }
  }
  if (null_value)
    result= protocol->store_null();
  return result;
unknown's avatar
unknown committed
1659 1660
}

1661 1662

bool Item_field::send(Protocol *protocol, String *buffer)
unknown's avatar
unknown committed
1663
{
1664
  return protocol->store(result_field);
unknown's avatar
unknown committed
1665 1666 1667 1668 1669 1670 1671
}

/*
  This is used for HAVING clause
  Find field in select list having the same name
 */

unknown's avatar
unknown committed
1672
bool Item_ref::fix_fields(THD *thd,TABLE_LIST *tables, Item **reference)
unknown's avatar
unknown committed
1673
{
1674
  DBUG_ASSERT(fixed == 0);
1675
  uint counter;
unknown's avatar
unknown committed
1676 1677
  if (!ref)
  {
1678
    TABLE_LIST *where= 0, *table_list;
1679
    bool upward_lookup= 0;
1680
    SELECT_LEX_UNIT *prev_unit= thd->lex->current_select->master_unit();
1681
    SELECT_LEX *sl= prev_unit->outer_select();
1682 1683 1684 1685 1686
    /*
      Finding only in current select will be performed for selects that have 
      not outer one and for derived tables (which not support using outer 
      fields for now)
    */
unknown's avatar
unknown committed
1687
    if ((ref= find_item_in_list(this, 
1688
				*(thd->lex->current_select->get_item_list()),
1689
				&counter,
1690
				((sl && 
1691
				  thd->lex->current_select->master_unit()->
1692
				  first_select()->linkage !=
1693 1694 1695
				  DERIVED_TABLE_TYPE) ? 
				  REPORT_EXCEPT_NOT_FOUND :
				  REPORT_ALL_ERRORS))) ==
unknown's avatar
unknown committed
1696
	(Item **)not_found_item)
unknown's avatar
unknown committed
1697
    {
1698
      upward_lookup= 1;
1699
      Field *tmp= (Field*) not_found_field;
unknown's avatar
unknown committed
1700
      /*
unknown's avatar
unknown committed
1701
	We can't find table field in table list of current select,
unknown's avatar
unknown committed
1702
	consequently we have to find it in outer subselect(s).
unknown's avatar
unknown committed
1703 1704 1705
	We can't join lists of outer & current select, because of scope
	of view rules. For example if both tables (outer & current) have
	field 'field' it is not mistake to refer to this field without
unknown's avatar
unknown committed
1706
	mention of table name, but if we join tables in one list it will
1707
	cause error ER_NON_UNIQ_ERROR in find_item_in_list.
unknown's avatar
unknown committed
1708 1709
      */
      SELECT_LEX *last=0;
1710
      for ( ; sl ; sl= (prev_unit= sl->master_unit())->outer_select())
1711
      {
1712
	last= sl;
unknown's avatar
unknown committed
1713
	Item_subselect *prev_subselect_item= prev_unit->item;
1714 1715
	if (sl->resolve_mode == SELECT_LEX::SELECT_MODE &&
	    (ref= find_item_in_list(this, sl->item_list,
1716 1717
				    &counter,
				    REPORT_EXCEPT_NOT_FOUND)) !=
unknown's avatar
unknown committed
1718
	   (Item **)not_found_item)
1719 1720 1721
	{
	  if (*ref && (*ref)->fixed) // Avoid crash in case of error
	  {
unknown's avatar
unknown committed
1722 1723
	    prev_subselect_item->used_tables_cache|= (*ref)->used_tables();
	    prev_subselect_item->const_item_cache&= (*ref)->const_item();
1724
	  }
1725
	  break;
1726
	}
1727
	table_list= sl->get_table_list();
1728
	if (sl->resolve_mode == SELECT_LEX::INSERT_MODE && table_list)
1729 1730 1731 1732
	{
	  // it is primary INSERT st_select_lex => skip first table resolving
	  table_list= table_list->next;
	}
1733
	if ((tmp= find_field_in_tables(thd, this,
1734
				       table_list, &where,
unknown's avatar
unknown committed
1735
				       0)) != not_found_field)
1736
	{
unknown's avatar
unknown committed
1737 1738
	  prev_subselect_item->used_tables_cache|= tmp->table->map;
	  prev_subselect_item->const_item_cache= 0;
unknown's avatar
unknown committed
1739
	  break;
1740 1741 1742
	}

	// Reference is not found => depend from outer (or just error)
unknown's avatar
unknown committed
1743 1744
	prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
	prev_subselect_item->const_item_cache= 0;
1745

1746 1747
	if (sl->master_unit()->first_select()->linkage ==
	    DERIVED_TABLE_TYPE)
1748
	  break; // do not look over derived table
1749
      }
1750

unknown's avatar
unknown committed
1751
      if (!ref)
1752
	return 1;
1753 1754 1755
      else if (!tmp)
	return -1;
      else if (ref == (Item **)not_found_item && tmp == not_found_field)
unknown's avatar
unknown committed
1756
      {
1757
	if (upward_lookup)
unknown's avatar
unknown committed
1758
	{
1759 1760 1761
	  // We can't say exactly what absend (table or field)
	  my_printf_error(ER_BAD_FIELD_ERROR, ER(ER_BAD_FIELD_ERROR), MYF(0),
			  full_name(), thd->where);
unknown's avatar
unknown committed
1762
	}
1763
	else
unknown's avatar
unknown committed
1764
	{
1765 1766
	  // Call to report error
	  find_item_in_list(this,
1767
			    *(thd->lex->current_select->get_item_list()),
1768 1769
			    &counter,
			    REPORT_ALL_ERRORS);
unknown's avatar
unknown committed
1770
	}
1771
        ref= 0;
unknown's avatar
unknown committed
1772
	return 1;
unknown's avatar
unknown committed
1773
      }
1774 1775 1776
      else if (tmp != not_found_field)
      {
	ref= 0; // To prevent "delete *ref;" on ~Item_erf() of this item
unknown's avatar
unknown committed
1777
	Item_field* fld;
unknown's avatar
unknown committed
1778
	if (!((*reference)= fld= new Item_field(tmp)))
1779
	  return 1;
1780
	register_item_tree_changing(reference);
1781
	mark_as_dependent(thd, last, thd->lex->current_select, fld);
1782 1783
	return 0;
      }
unknown's avatar
unknown committed
1784 1785
      else
      {
1786 1787 1788 1789 1790 1791
	if (!(*ref)->fixed)
	{
	  my_error(ER_ILLEGAL_REFERENCE, MYF(0), name,
		   "forward reference in item list");
	  return -1;
	}
1792
	mark_as_dependent(thd, last, thd->lex->current_select,
unknown's avatar
unknown committed
1793 1794
			  this);
	ref= last->ref_pointer_array + counter;
unknown's avatar
unknown committed
1795 1796
      }
    }
1797
    else if (!ref)
unknown's avatar
unknown committed
1798
      return 1;
1799 1800 1801 1802 1803 1804 1805 1806
    else
    {
      if (!(*ref)->fixed)
      {
	my_error(ER_ILLEGAL_REFERENCE, MYF(0), name,
		 "forward reference in item list");
	return -1;
      }
1807
      ref= thd->lex->current_select->ref_pointer_array + counter;
1808
    }
unknown's avatar
unknown committed
1809
  }
1810

1811 1812 1813 1814 1815 1816 1817
  /*
    The following conditional is changed as to correctly identify 
    incorrect references in group functions or forward references 
    with sub-select's / derived tables, while it prevents this 
    check when Item_ref is created in an expression involving 
    summing function, which is to be placed in the user variable.
  */
1818
  if (((*ref)->with_sum_func && name &&
1819
       (depended_from ||
1820 1821
	!(thd->lex->current_select->linkage != GLOBAL_OPTIONS_TYPE &&
	  thd->lex->current_select->having_fix_field))) ||
1822 1823 1824 1825 1826 1827 1828 1829
      !(*ref)->fixed)
  {
    my_error(ER_ILLEGAL_REFERENCE, MYF(0), name, 
	     ((*ref)->with_sum_func?
	      "reference on group function":
	      "forward reference in item list"));
    return 1;
  }
1830 1831 1832
  max_length= (*ref)->max_length;
  maybe_null= (*ref)->maybe_null;
  decimals=   (*ref)->decimals;
1833
  collation.set((*ref)->collation);
unknown's avatar
unknown committed
1834
  with_sum_func= (*ref)->with_sum_func;
1835
  fixed= 1;
1836

unknown's avatar
unknown committed
1837 1838
  if (ref && (*ref)->check_cols(1))
    return 1;
unknown's avatar
unknown committed
1839 1840 1841
  return 0;
}

1842

unknown's avatar
unknown committed
1843 1844
void Item_ref::cleanup()
{
unknown's avatar
unknown committed
1845
  DBUG_ENTER("Item_ref::cleanup");
unknown's avatar
unknown committed
1846 1847 1848
  Item_ident::cleanup();
  if (hook_ptr)
    *hook_ptr= orig_item;
unknown's avatar
unknown committed
1849
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1850 1851 1852
}


unknown's avatar
unknown committed
1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863
void Item_ref::print(String *str)
{
  if (ref && *ref)
    (*ref)->print(str);
  else
    Item_ident::print(str);
}


void Item_ref_null_helper::print(String *str)
{
1864
  str->append("<ref_null_helper>(", 18);
unknown's avatar
unknown committed
1865 1866 1867 1868 1869 1870 1871 1872 1873 1874
  if (ref && *ref)
    (*ref)->print(str);
  else
    str->append('?');
  str->append(')');
}


void Item_null_helper::print(String *str)
{
1875
  str->append("<null_helper>(", 14);
unknown's avatar
unknown committed
1876 1877 1878 1879 1880
  store->print(str);
  str->append(')');
}


unknown's avatar
SCRUM  
unknown committed
1881 1882
bool Item_default_value::eq(const Item *item, bool binary_cmp) const
{
unknown's avatar
SCRUM  
unknown committed
1883
  return item->type() == DEFAULT_VALUE_ITEM && 
unknown's avatar
SCRUM  
unknown committed
1884 1885 1886
    ((Item_default_value *)item)->arg->eq(arg, binary_cmp);
}

1887

1888 1889 1890
bool Item_default_value::fix_fields(THD *thd,
				    struct st_table_list *table_list,
				    Item **items)
unknown's avatar
SCRUM  
unknown committed
1891
{
1892
  DBUG_ASSERT(fixed == 0);
unknown's avatar
SCRUM  
unknown committed
1893
  if (!arg)
1894 1895
  {
    fixed= 1;
1896
    return 0;
1897
  }
1898 1899 1900
  if (arg->fix_fields(thd, table_list, &arg))
    return 1;
  
unknown's avatar
SCRUM  
unknown committed
1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914
  if (arg->type() == REF_ITEM)
  {
    Item_ref *ref= (Item_ref *)arg;
    if (ref->ref[0]->type() != FIELD_ITEM)
    {
      return 1;
    }
    arg= ref->ref[0];
  }
  Item_field *field_arg= (Item_field *)arg;
  Field *def_field= (Field*) sql_alloc(field_arg->field->size_of());
  if (!def_field)
    return 1;
  memcpy(def_field, field_arg->field, field_arg->field->size_of());
unknown's avatar
unknown committed
1915 1916
  def_field->move_field(def_field->table->default_values -
                        def_field->table->record[0]);
unknown's avatar
SCRUM  
unknown committed
1917
  set_field(def_field);
1918
  fixed= 1;
unknown's avatar
SCRUM  
unknown committed
1919 1920 1921
  return 0;
}

unknown's avatar
SCRUM  
unknown committed
1922 1923
void Item_default_value::print(String *str)
{
unknown's avatar
SCRUM  
unknown committed
1924 1925
  if (!arg)
  {
unknown's avatar
unknown committed
1926
    str->append("default", 7);
unknown's avatar
SCRUM  
unknown committed
1927
    return;
unknown's avatar
SCRUM  
unknown committed
1928
  }
unknown's avatar
unknown committed
1929
  str->append("default(", 8);
unknown's avatar
SCRUM  
unknown committed
1930 1931 1932
  arg->print(str);
  str->append(')');
}
1933

unknown's avatar
unknown committed
1934 1935 1936 1937 1938 1939 1940
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);
}


1941 1942 1943
bool Item_insert_value::fix_fields(THD *thd,
				   struct st_table_list *table_list,
				   Item **items)
unknown's avatar
unknown committed
1944
{
1945
  DBUG_ASSERT(fixed == 0);
1946 1947 1948
  if (arg->fix_fields(thd, table_list, &arg))
    return 1;

unknown's avatar
unknown committed
1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970
  if (arg->type() == REF_ITEM)
  {
    Item_ref *ref= (Item_ref *)arg;
    if (ref->ref[0]->type() != FIELD_ITEM)
    {
      return 1;
    }
    arg= ref->ref[0];
  }
  Item_field *field_arg= (Item_field *)arg;
  if (field_arg->field->table->insert_values)
  {
    Field *def_field= (Field*) sql_alloc(field_arg->field->size_of());
    if (!def_field)
      return 1;
    memcpy(def_field, field_arg->field, field_arg->field->size_of());
    def_field->move_field(def_field->table->insert_values -
                          def_field->table->record[0]);
    set_field(def_field);
  }
  else
  {
1971
    Field *tmp_field= field_arg->field;
unknown's avatar
unknown committed
1972
    /* charset doesn't matter here, it's to avoid sigsegv only */
1973 1974
    set_field(new Field_null(0, 0, Field::NONE, tmp_field->field_name,
			     tmp_field->table, &my_charset_bin));
unknown's avatar
unknown committed
1975
  }
1976
  fixed= 1;
unknown's avatar
unknown committed
1977 1978 1979 1980 1981
  return 0;
}

void Item_insert_value::print(String *str)
{
1982
  str->append("values(", 7);
unknown's avatar
unknown committed
1983 1984 1985 1986
  arg->print(str);
  str->append(')');
}

unknown's avatar
unknown committed
1987
/*
1988 1989
  If item is a const function, calculate it and return a const item
  The original item is freed if not returned
unknown's avatar
unknown committed
1990 1991 1992 1993 1994 1995
*/

Item_result item_cmp_type(Item_result a,Item_result b)
{
  if (a == STRING_RESULT && b == STRING_RESULT)
    return STRING_RESULT;
1996
  if (a == INT_RESULT && b == INT_RESULT)
unknown's avatar
unknown committed
1997
    return INT_RESULT;
unknown's avatar
unknown committed
1998 1999
  else if (a == ROW_RESULT || b == ROW_RESULT)
    return ROW_RESULT;
2000
  return REAL_RESULT;
unknown's avatar
unknown committed
2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
}


Item *resolve_const_item(Item *item,Item *comp_item)
{
  if (item->basic_const_item())
    return item;				// Can't be better
  Item_result res_type=item_cmp_type(comp_item->result_type(),
				     item->result_type());
  char *name=item->name;			// Alloced by sql_alloc

  if (res_type == STRING_RESULT)
  {
    char buff[MAX_FIELD_WIDTH];
unknown's avatar
unknown committed
2015
    String tmp(buff,sizeof(buff),&my_charset_bin),*result;
unknown's avatar
unknown committed
2016 2017 2018 2019 2020
    result=item->val_str(&tmp);
    if (item->null_value)
      return new Item_null(name);
    uint length=result->length();
    char *tmp_str=sql_strmake(result->ptr(),length);
unknown's avatar
unknown committed
2021
    return new Item_string(name,tmp_str,length,result->charset());
unknown's avatar
unknown committed
2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055
  }
  if (res_type == INT_RESULT)
  {
    longlong result=item->val_int();
    uint length=item->max_length;
    bool null_value=item->null_value;
    return (null_value ? (Item*) new Item_null(name) :
	    (Item*) new Item_int(name,result,length));
  }
  else
  {						// It must REAL_RESULT
    double result=item->val();
    uint length=item->max_length,decimals=item->decimals;
    bool null_value=item->null_value;
    return (null_value ? (Item*) new Item_null(name) :
	    (Item*) new Item_real(name,result,decimals,length));
  }
}

/*
  Return true if the value stored in the field is equal to the const item
  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];
unknown's avatar
unknown committed
2056 2057
    String item_tmp(item_buff,sizeof(item_buff),&my_charset_bin),*item_result;
    String field_tmp(field_buff,sizeof(field_buff),&my_charset_bin);
unknown's avatar
unknown committed
2058 2059 2060
    item_result=item->val_str(&item_tmp);
    if (item->null_value)
      return 1;					// This must be true
2061
    field->val_str(&field_tmp);
unknown's avatar
unknown committed
2062
    return !stringcmp(&field_tmp,item_result);
unknown's avatar
unknown committed
2063 2064 2065 2066 2067 2068 2069 2070 2071
  }
  if (res_type == INT_RESULT)
    return 1;					// Both where of type int
  double result=item->val();
  if (item->null_value)
    return 1;
  return result == field->val_real();
}

2072 2073 2074 2075 2076 2077 2078 2079 2080 2081
Item_cache* Item_cache::get_cache(Item_result type)
{
  switch (type)
  {
  case INT_RESULT:
    return new Item_cache_int();
  case REAL_RESULT:
    return new Item_cache_real();
  case STRING_RESULT:
    return new Item_cache_str();
unknown's avatar
unknown committed
2082 2083
  case ROW_RESULT:
    return new Item_cache_row();
2084 2085 2086 2087 2088 2089 2090
  default:
    // should never be in real life
    DBUG_ASSERT(0);
    return 0;
  }
}

unknown's avatar
unknown committed
2091 2092 2093

void Item_cache::print(String *str)
{
2094
  str->append("<cache>(", 8);
unknown's avatar
unknown committed
2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116
  if (example)
    example->print(str);
  else
    Item::print(str);
  str->append(')');
}


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


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


2117 2118
void Item_cache_str::store(Item *item)
{
unknown's avatar
merge  
unknown committed
2119
  value_buff.set(buffer, sizeof(buffer), item->collation.collation);
2120
  value= item->str_result(&value_buff);
2121 2122
  if ((null_value= item->null_value))
    value= 0;
2123
  else if (value != &value_buff)
2124 2125 2126 2127 2128 2129 2130 2131 2132
  {
    /*
      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;
    */
2133 2134
    value_buff.copy(*value);
    value= &value_buff;
2135 2136
  }
}
2137 2138


2139
double Item_cache_str::val()
2140 2141
{
  DBUG_ASSERT(fixed == 1);
2142
  int err;
2143
  if (value)
2144
    return my_strntod(value->charset(), (char*) value->ptr(),
2145
		      value->length(), (char**) 0, &err);
2146 2147 2148
  else
    return (double)0;
}
2149 2150


2151 2152
longlong Item_cache_str::val_int()
{
2153
  DBUG_ASSERT(fixed == 1);
2154
  int err;
2155 2156
  if (value)
    return my_strntoll(value->charset(), value->ptr(),
2157
		       value->length(), 10, (char**) 0, &err);
2158 2159 2160
  else
    return (longlong)0;
}
unknown's avatar
unknown committed
2161

2162

unknown's avatar
unknown committed
2163 2164
bool Item_cache_row::allocate(uint num)
{
unknown's avatar
unknown committed
2165
  item_count= num;
unknown's avatar
unknown committed
2166
  THD *thd= current_thd;
unknown's avatar
unknown committed
2167 2168
  return (!(values= 
	    (Item_cache **) thd->calloc(sizeof(Item_cache *)*item_count)));
unknown's avatar
unknown committed
2169 2170
}

2171

unknown's avatar
unknown committed
2172 2173
bool Item_cache_row::setup(Item * item)
{
unknown's avatar
unknown committed
2174
  example= item;
unknown's avatar
unknown committed
2175 2176
  if (!values && allocate(item->cols()))
    return 1;
unknown's avatar
unknown committed
2177
  for (uint i= 0; i < item_count; i++)
unknown's avatar
unknown committed
2178
  {
unknown's avatar
unknown committed
2179
    Item *el= item->el(i);
unknown's avatar
unknown committed
2180 2181
    Item_cache *tmp;
    if (!(tmp= values[i]= Item_cache::get_cache(el->result_type())))
unknown's avatar
unknown committed
2182
      return 1;
unknown's avatar
unknown committed
2183
    tmp->setup(el);
unknown's avatar
unknown committed
2184 2185 2186 2187
  }
  return 0;
}

2188

unknown's avatar
unknown committed
2189 2190 2191 2192
void Item_cache_row::store(Item * item)
{
  null_value= 0;
  item->bring_value();
unknown's avatar
unknown committed
2193
  for (uint i= 0; i < item_count; i++)
unknown's avatar
unknown committed
2194 2195 2196 2197 2198 2199
  {
    values[i]->store(item->el(i));
    null_value|= values[i]->null_value;
  }
}

2200

unknown's avatar
unknown committed
2201 2202 2203 2204 2205
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);
unknown's avatar
unknown committed
2206
  my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
unknown's avatar
unknown committed
2207 2208 2209
  DBUG_VOID_RETURN;
}

2210

unknown's avatar
unknown committed
2211 2212
bool Item_cache_row::check_cols(uint c)
{
unknown's avatar
unknown committed
2213
  if (c != item_count)
unknown's avatar
unknown committed
2214
  {
unknown's avatar
unknown committed
2215
    my_error(ER_OPERAND_COLUMNS, MYF(0), c);
unknown's avatar
unknown committed
2216 2217 2218 2219 2220
    return 1;
  }
  return 0;
}

2221

unknown's avatar
unknown committed
2222 2223
bool Item_cache_row::null_inside()
{
unknown's avatar
unknown committed
2224
  for (uint i= 0; i < item_count; i++)
unknown's avatar
unknown committed
2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240
  {
    if (values[i]->cols() > 1)
    {
      if (values[i]->null_inside())
	return 1;
    }
    else
    {
      values[i]->val_int();
      if (values[i]->null_value)
	return 1;
    }
  }
  return 0;
}

2241

unknown's avatar
unknown committed
2242 2243
void Item_cache_row::bring_value()
{
unknown's avatar
unknown committed
2244
  for (uint i= 0; i < item_count; i++)
unknown's avatar
unknown committed
2245 2246 2247
    values[i]->bring_value();
  return;
}
unknown's avatar
unknown committed
2248

2249 2250

Item_type_holder::Item_type_holder(THD *thd, Item *item)
2251 2252
  :Item(thd, item), item_type(item->result_type()),
   orig_type(item_type)
2253 2254
{
  DBUG_ASSERT(item->fixed);
unknown's avatar
unknown committed
2255 2256 2257 2258 2259

  /*
    It is safe assign pointer on field, because it will be used just after
    all JOIN::prepare calls and before any SELECT execution
  */
2260
  if (item->type() == Item::FIELD_ITEM)
unknown's avatar
unknown committed
2261
    field_example= ((Item_field*) item)->field;
2262 2263
  else
    field_example= 0;
2264
  collation.set(item->collation);
2265 2266 2267
}


2268 2269 2270 2271 2272 2273 2274
/*
  STRING_RESULT, REAL_RESULT, INT_RESULT, ROW_RESULT

  ROW_RESULT should never appear in Item_type_holder::join_types,
  but it is included in following table just to make table full
  (there DBUG_ASSERT in function to catch ROW_RESULT)
*/
2275 2276 2277 2278 2279 2280
static Item_result type_convertor[4][4]=
{{STRING_RESULT, STRING_RESULT, STRING_RESULT, ROW_RESULT},
 {STRING_RESULT, REAL_RESULT,   REAL_RESULT,   ROW_RESULT},
 {STRING_RESULT, REAL_RESULT,   INT_RESULT,    ROW_RESULT},
 {ROW_RESULT,    ROW_RESULT,    ROW_RESULT,    ROW_RESULT}};

2281
bool Item_type_holder::join_types(THD *thd, Item *item)
2282 2283 2284 2285 2286 2287 2288 2289
{
  bool change_field= 0, skip_store_field= 0;
  Item_result new_type= type_convertor[item_type][item->result_type()];

  // we have both fields
  if (field_example && item->type() == Item::FIELD_ITEM)
  {
    Field *field= ((Item_field *)item)->field;
unknown's avatar
unknown committed
2290
    if (field_example->field_cast_type() != field->field_cast_type())
2291
    {
unknown's avatar
unknown committed
2292 2293 2294 2295 2296 2297 2298 2299 2300 2301
      if (!(change_field=
	    field_example->field_cast_compatible(field->field_cast_type())))
      {
	/*
	  if old field can't store value of 'worse' new field we will make
	  decision about result field type based only on Item result type
	*/
	if (!field->field_cast_compatible(field_example->field_cast_type()))
	  skip_store_field= 1;
      }
2302 2303 2304 2305 2306 2307 2308 2309 2310
    }
  }

  // size/type should be changed
  if (change_field ||
      (new_type != item_type) ||
      (max_length < item->max_length) ||
      ((new_type == INT_RESULT) &&
       (decimals < item->decimals)) ||
2311 2312 2313
      (!maybe_null && item->maybe_null) ||
      (item_type == STRING_RESULT && new_type == STRING_RESULT &&
       !my_charset_same(collation.collation, item->collation.collation)))
2314 2315 2316 2317 2318 2319
  {
    // new field has some parameters worse then current
    skip_store_field|= (change_field &&
			(max_length > item->max_length) ||
			((new_type == INT_RESULT) &&
			 (decimals > item->decimals)) ||
2320 2321 2322 2323 2324
			(maybe_null && !item->maybe_null) ||
			(item_type == STRING_RESULT &&
			 new_type == STRING_RESULT &&
			 !my_charset_same(collation.collation,
					  item->collation.collation)));
unknown's avatar
unknown committed
2325 2326 2327 2328
    /*
      It is safe assign pointer on field, because it will be used just after
      all JOIN::prepare calls and before any SELECT execution
    */
2329 2330 2331
    if (skip_store_field || item->type() != Item::FIELD_ITEM)
      field_example= 0;
    else
unknown's avatar
unknown committed
2332 2333
      field_example= ((Item_field*) item)->field;

2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345
    const char *old_cs= collation.collation->name,
      *old_derivation= collation.derivation_name();
    if (item_type == STRING_RESULT && collation.aggregate(item->collation))
    {
      my_error(ER_CANT_AGGREGATE_2COLLATIONS, MYF(0),
	       old_cs, old_derivation,
	       item->collation.collation->name,
	       item->collation.derivation_name(),
	       "UNION");
      return 1;
    }

2346 2347 2348 2349 2350 2351
    max_length= max(max_length, item->max_length);
    decimals= max(decimals, item->decimals);
    maybe_null|= item->maybe_null;
    item_type= new_type;
  }
  DBUG_ASSERT(item_type != ROW_RESULT);
2352
  return 0;
2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375
}


double Item_type_holder::val()
{
  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;
}


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

unknown's avatar
unknown committed
2376 2377 2378 2379 2380 2381 2382
/*****************************************************************************
** Instantiate templates
*****************************************************************************/

#ifdef __GNUC__
template class List<Item>;
template class List_iterator<Item>;
unknown's avatar
unknown committed
2383
template class List_iterator_fast<Item>;
unknown's avatar
unknown committed
2384 2385
template class List<List_item>;
#endif