item.cc 63.8 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);

30 31
const String my_null_string("NULL", 4, default_charset_info);

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

/* Init all special items */

void item_init(void)
{
  item_user_lock_init();
}

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

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

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

unknown's avatar
unknown committed
93 94 95 96 97 98

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


unknown's avatar
unknown committed
106 107
Item_ident::Item_ident(const char *db_name_par,const char *table_name_par,
		       const char *field_name_par)
unknown's avatar
unknown committed
108
  :orig_db_name(db_name_par), orig_table_name(table_name_par), 
109 110 111 112
   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
113 114 115 116
{
  name = (char*) field_name_par;
}

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

132 133
void Item_ident::cleanup()
{
unknown's avatar
unknown committed
134 135 136 137 138
  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));
139 140 141 142 143 144
  Item::cleanup();
  if (changed_during_fix_field)
  {
    *changed_during_fix_field= this;
    changed_during_fix_field= 0;
  }
145 146 147
  db_name= orig_db_name; 
  table_name= orig_table_name;
  field_name= orig_field_name;
unknown's avatar
unknown committed
148
  DBUG_VOID_RETURN;
149 150
}

unknown's avatar
unknown committed
151 152 153 154 155
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;
156
  DBUG_RETURN(0);
unknown's avatar
unknown committed
157 158 159
}


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

unknown's avatar
unknown committed
170 171

void Item::set_name(const char *str, uint length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
172 173 174
{
  if (!length)
  {
unknown's avatar
unknown committed
175 176 177 178
    /* Empty string, used by AS or internal function like last_insert_id() */
    name= (char*) str;
    return;
  }
179 180 181 182 183 184 185 186 187
  if (cs->ctype)
  {
    // This will probably need a better implementation in the future:
    // a function in CHARSET_INFO structure.
    while (length && !my_isgraph(cs,*str))
    {						// Fix problem with yacc
      length--;
      str++;
    }
unknown's avatar
unknown committed
188
  }
unknown's avatar
unknown committed
189 190 191 192 193 194 195 196 197
  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
198 199
}

unknown's avatar
unknown committed
200

201
/*
202 203 204
  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
205 206 207
*/

bool Item::eq(const Item *item, bool binary_cmp) const
unknown's avatar
unknown committed
208 209
{
  return type() == item->type() && name && item->name &&
210
    !my_strcasecmp(system_charset_info,name,item->name);
unknown's avatar
unknown committed
211 212
}

unknown's avatar
unknown committed
213

214 215 216 217 218
bool Item_string::eq(const Item *item, bool binary_cmp) const
{
  if (type() == item->type())
  {
    if (binary_cmp)
unknown's avatar
unknown committed
219
      return !stringcmp(&str_value, &item->str_value);
220
    return !sortcmp(&str_value, &item->str_value, collation.collation);
221 222 223 224 225
  }
  return 0;
}


unknown's avatar
unknown committed
226 227 228 229 230
/*
  Get the value of the function as a TIME structure.
  As a extra convenience the time structure is reset on error!
 */

231
bool Item::get_date(TIME *ltime,uint fuzzydate)
unknown's avatar
unknown committed
232 233
{
  char buff[40];
unknown's avatar
unknown committed
234
  String tmp(buff,sizeof(buff), &my_charset_bin),*res;
unknown's avatar
unknown committed
235
  if (!(res=val_str(&tmp)) ||
236 237
      str_to_datetime_with_warn(res->ptr(), res->length(),
                                ltime, fuzzydate) <= MYSQL_TIMESTAMP_ERROR)
unknown's avatar
unknown committed
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
  {
    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
253
  String tmp(buff,sizeof(buff),&my_charset_bin),*res;
unknown's avatar
unknown committed
254
  if (!(res=val_str(&tmp)) ||
255
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
unknown's avatar
unknown committed
256 257 258 259 260 261 262
  {
    bzero((char*) ltime,sizeof(*ltime));
    return 1;
  }
  return 0;
}

263
CHARSET_INFO *Item::default_charset()
264
{
unknown's avatar
unknown committed
265
  return current_thd->variables.collation_connection;
266 267
}

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

unknown's avatar
unknown committed
327
Item_field::Item_field(Field *f)
328
  :Item_ident(NullS, f->table_name, f->field_name)
unknown's avatar
unknown committed
329 330
{
  set_field(f);
331
  collation.set(DERIVATION_IMPLICIT);
unknown's avatar
unknown committed
332
  fixed= 1;
unknown's avatar
unknown committed
333 334
}

335 336 337 338 339 340 341 342 343
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;
}

344
// Constructor need to process subselect with temporary tables (see Item)
345
Item_field::Item_field(THD *thd, Item_field *item)
346
  :Item_ident(thd, item),
347 348
   field(item->field),
   result_field(item->result_field)
349 350 351
{
  collation.set(DERIVATION_IMPLICIT);
}
unknown's avatar
unknown committed
352 353 354 355 356 357 358 359 360

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;
361
  db_name=field_par->table->table_cache_key;
362
  unsigned_flag=test(field_par->flags & UNSIGNED_FLAG);
363
  collation.set(field_par->charset(), DERIVATION_IMPLICIT);
unknown's avatar
unknown committed
364 365 366 367 368
}

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

/* ARGSUSED */
String *Item_field::val_str(String *str)
{
394
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
395 396
  if ((null_value=field->is_null()))
    return 0;
397
  str->set_charset(str_value.charset());
unknown's avatar
unknown committed
398 399 400 401 402
  return field->val_str(str,&str_value);
}

double Item_field::val()
{
403
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
404 405 406 407 408 409 410
  if ((null_value=field->is_null()))
    return 0.0;
  return field->val_real();
}

longlong Item_field::val_int()
{
411
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
412 413 414 415 416 417 418 419 420 421
  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;
422
  str->set_charset(str_value.charset());
unknown's avatar
unknown committed
423 424 425
  return result_field->val_str(str,&str_value);
}

426
bool Item_field::get_date(TIME *ltime,uint fuzzydate)
unknown's avatar
unknown committed
427 428 429 430 431 432 433 434 435
{
  if ((null_value=field->is_null()) || field->get_date(ltime,fuzzydate))
  {
    bzero((char*) ltime,sizeof(*ltime));
    return 1;
  }
  return 0;
}

436
bool Item_field::get_date_result(TIME *ltime,uint fuzzydate)
437 438 439 440 441 442 443 444 445 446
{
  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
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470
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();
}

471

472
bool Item_field::eq(const Item *item, bool binary_cmp) const
unknown's avatar
unknown committed
473
{
474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
  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 ||
496 497
	     (item_field->db_name && !strcmp(item_field->db_name,
					     db_name))))));
unknown's avatar
unknown committed
498 499
}

500

unknown's avatar
unknown committed
501 502 503 504
table_map Item_field::used_tables() const
{
  if (field->table->const_table)
    return 0;					// const item
unknown's avatar
unknown committed
505
  return (depended_from ? OUTER_REF_TABLE_BIT : field->table->map);
unknown's avatar
unknown committed
506 507
}

508

509
Item *Item_field::get_tmp_table_item(THD *thd)
510
{
511
  Item_field *new_item= new Item_field(thd, this);
512 513 514 515
  if (new_item)
    new_item->field= new_item->result_field;
  return new_item;
}
unknown's avatar
unknown committed
516

517

unknown's avatar
unknown committed
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
/*
  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
534 535
String *Item_int::val_str(String *str)
{
unknown's avatar
unknown committed
536
  // following assert is redundant, because fixed=1 assigned in constructor
537
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
538
  str->set(value, &my_charset_bin);
unknown's avatar
unknown committed
539 540 541 542 543
  return str;
}

void Item_int::print(String *str)
{
unknown's avatar
unknown committed
544 545
  // my_charset_bin is good enough for numbers
  str_value.set(value, &my_charset_bin);
unknown's avatar
unknown committed
546
  str->append(str_value);
unknown's avatar
unknown committed
547 548
}

549

unknown's avatar
unknown committed
550 551 552 553 554 555 556
Item_uint::Item_uint(const char *str_arg, uint length):
  Item_int(str_arg, length)
{
  unsigned_flag= 1;
}


unknown's avatar
unknown committed
557 558
String *Item_uint::val_str(String *str)
{
unknown's avatar
unknown committed
559
  // following assert is redundant, because fixed=1 assigned in constructor
560
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
561
  str->set((ulonglong) value, &my_charset_bin);
unknown's avatar
unknown committed
562 563 564
  return str;
}

565

unknown's avatar
unknown committed
566 567
void Item_uint::print(String *str)
{
568
  // latin1 is good enough for numbers
unknown's avatar
unknown committed
569 570
  str_value.set((ulonglong) value, default_charset());
  str->append(str_value);
unknown's avatar
unknown committed
571 572
}

unknown's avatar
unknown committed
573 574 575

String *Item_real::val_str(String *str)
{
unknown's avatar
unknown committed
576
  // following assert is redundant, because fixed=1 assigned in constructor
577
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
578
  str->set(value,decimals,&my_charset_bin);
unknown's avatar
unknown committed
579 580 581
  return str;
}

582

unknown's avatar
unknown committed
583 584
void Item_string::print(String *str)
{
585 586
  str->append('_');
  str->append(collation.collation->csname);
unknown's avatar
unknown committed
587
  str->append('\'');
unknown's avatar
unknown committed
588
  str_value.print(str);
unknown's avatar
unknown committed
589 590 591
  str->append('\'');
}

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


618 619 620 621 622 623 624 625 626 627 628 629 630 631 632
/*********************** 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();
}

633 634
Item_param::Item_param(unsigned pos_in_query_arg) :
  state(NO_VALUE),
635
  item_result_type(STRING_RESULT),
636 637
  /* Don't pretend to be a literal unless value for this item is set. */
  item_type(PARAM_ITEM),
638
  param_type(MYSQL_TYPE_STRING),
639
  pos_in_query(pos_in_query_arg),
640 641 642
  set_param_func(default_set_param_func)
{
  name= (char*) "?";
643 644 645 646 647 648
  /* 
    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;
649 650
}

unknown's avatar
unknown committed
651
void Item_param::set_null()
652 653
{
  DBUG_ENTER("Item_param::set_null");
654
  /* These are cleared after each execution by reset() method */
655
  max_length= 0;
656 657 658 659 660 661 662 663 664
  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;
665
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
666 667
}

668
void Item_param::set_int(longlong i, uint32 max_length_arg)
669 670
{
  DBUG_ENTER("Item_param::set_int");
671 672 673 674
  value.integer= (longlong) i;
  state= INT_VALUE;
  max_length= max_length_arg;
  decimals= 0;
675
  maybe_null= 0;
676
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
677 678
}

679
void Item_param::set_double(double d)
680 681
{
  DBUG_ENTER("Item_param::set_double");
682 683 684
  value.real= d;
  state= REAL_VALUE;
  max_length= DBL_DIG + 8;
685
  decimals= NOT_FIXED_DEC;
686
  maybe_null= 0;
687
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
688 689
}

690

691
void Item_param::set_time(TIME *tm, timestamp_type type, uint32 max_length_arg)
692
{ 
693
  DBUG_ENTER("Item_param::set_time");
694

695 696
  value.time= *tm;
  value.time.time_type= type;
697

698 699 700 701 702 703
  state= TIME_VALUE;
  maybe_null= 0;
  max_length= max_length_arg;
  decimals= 0;
  DBUG_VOID_RETURN;
}
unknown's avatar
unknown committed
704

705 706 707 708 709 710 711 712 713 714 715

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.
  */
  if (str_value.copy(str, length, &my_charset_bin, &my_charset_bin))
    DBUG_RETURN(TRUE);
  state= STRING_VALUE;
716
  maybe_null= 0;
717 718 719
  /* 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);
720 721 722
}


723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
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;
739
  maybe_null= 0;
740 741

  DBUG_RETURN(FALSE);
742 743 744
}


745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
/*
  Set parameter value from user variable value.

  SYNOPSIS
   set_from_user_var
     thd   Current thread
     entry User variable structure (NULL means use NULL value)

  RETURN
    0 OK
    1 Out of memort
*/

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;
unknown's avatar
unknown committed
764 765 766
    switch (entry->type) {
    case REAL_RESULT:
      set_double(*(double*)entry->value);
767 768
      item_type= Item::REAL_ITEM;
      item_result_type= REAL_RESULT;
unknown's avatar
unknown committed
769 770 771
      break;
    case INT_RESULT:
      set_int(*(longlong*)entry->value, 21);
772 773
      item_type= Item::INT_ITEM;
      item_result_type= INT_RESULT;
unknown's avatar
unknown committed
774 775
      break;
    case STRING_RESULT:
776
    {
unknown's avatar
unknown committed
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803
      CHARSET_INFO *fromcs= entry->collation.collation;
      CHARSET_INFO *tocs= thd->variables.collation_connection;
      uint32 dummy_offset;

      value.cs_info.character_set_client= fromcs;
      /*
        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;
      item_result_type= STRING_RESULT;

      if (set_str((const char *)entry->value, entry->length))
        DBUG_RETURN(1);
      break;
    }
    default:
      DBUG_ASSERT(0);
      set_null();
804 805 806 807 808 809 810 811
    }
  }
  else
    set_null();

  DBUG_RETURN(0);
}

812 813 814 815 816 817 818 819 820 821 822 823
/*
    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()
824 825 826 827 828 829
{
  /* 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);
830
  str_value_ptr.length(0);
831
  /*
832 833
    We must prevent all charset conversions untill data has been written
    to the binary log.
834 835 836
  */
  str_value.set_charset(&my_charset_bin);
  state= NO_VALUE;
837 838
  maybe_null= 1;
  null_value= 0;
839 840 841 842 843 844 845 846 847
  /*
    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).
  */
unknown's avatar
unknown committed
848 849 850
}


unknown's avatar
unknown committed
851
int Item_param::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
852 853
{
  field->set_notnull();
854 855 856 857 858 859 860 861

  switch (state) {
  case INT_VALUE:
    return field->store(value.integer);
  case REAL_VALUE:
    return field->store(value.real);
  case TIME_VALUE:
    field->store_time(&value.time, value.time.time_type);
862
    return 0;
863 864 865 866 867 868 869 870 871
  case STRING_VALUE:
  case LONG_DATA_VALUE:
    return field->store(str_value.ptr(), str_value.length(),
                        str_value.charset());
  case NULL_VALUE:
    return set_field_to_null(field);
  case NO_VALUE:
  default:
    DBUG_ASSERT(0);
unknown's avatar
unknown committed
872
  }
873
  return 1;
unknown's avatar
unknown committed
874 875
}

876

877 878
bool Item_param::get_time(TIME *res)
{
879 880 881 882 883 884 885 886 887 888
  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);
889
}
890

891

892 893 894 895 896 897 898 899 900 901 902
bool Item_param::get_date(TIME *res, uint fuzzydate)
{
  if (state == TIME_VALUE)
  {
    *res= value.time;
    return 0;
  }
  return Item::get_date(res, fuzzydate);
}


unknown's avatar
unknown committed
903 904
double Item_param::val() 
{
905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
  switch (state) {
  case REAL_VALUE:
    return value.real;
  case INT_VALUE:
    return (double) value.integer;
  case STRING_VALUE:
  case LONG_DATA_VALUE:
    {
      int dummy_err;
      return my_strntod(str_value.charset(), (char*) str_value.ptr(),
                        str_value.length(), (char**) 0, &dummy_err);
    }
  case TIME_VALUE:
    /*
      This works for example when user says SELECT ?+0.0 and supplies
      time value for the placeholder.
    */
    return (double) TIME_to_ulonglong(&value.time);
  case NULL_VALUE:
924
    return 0.0;
unknown's avatar
unknown committed
925
  default:
926
    DBUG_ASSERT(0);
unknown's avatar
unknown committed
927
  }
928
  return 0.0;
unknown's avatar
unknown committed
929 930
} 

931

unknown's avatar
unknown committed
932 933
longlong Item_param::val_int() 
{ 
934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949
  switch (state) {
  case REAL_VALUE:
    return (longlong) (value.real + (value.real > 0 ? 0.5 : -0.5));
  case INT_VALUE:
    return value.integer;
  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; 
unknown's avatar
unknown committed
950
  default:
951
    DBUG_ASSERT(0);
unknown's avatar
unknown committed
952
  }
953
  return 0;
unknown's avatar
unknown committed
954 955
}

956

unknown's avatar
unknown committed
957 958
String *Item_param::val_str(String* str) 
{ 
959 960 961
  switch (state) {
  case STRING_VALUE:
  case LONG_DATA_VALUE:
962
    return &str_value_ptr;
963 964 965 966 967
  case REAL_VALUE:
    str->set(value.real, NOT_FIXED_DEC, &my_charset_bin);
    return str;
  case INT_VALUE:
    str->set(value.integer, &my_charset_bin);
unknown's avatar
unknown committed
968
    return str;
969 970 971 972 973
  case TIME_VALUE:
  {
    if (str->reserve(MAX_DATE_REP_LENGTH))
      break;
    TIME_to_string(&value.time, str);
unknown's avatar
unknown committed
974
    return str;
975 976 977
  }
  case NULL_VALUE:
    return NULL; 
unknown's avatar
unknown committed
978
  default:
979
    DBUG_ASSERT(0);
unknown's avatar
unknown committed
980
  }
981
  return str;
unknown's avatar
unknown committed
982
}
983 984 985 986

/*
  Return Param item values in string format, for generating the dynamic 
  query used in update/binary logs
987 988
  TODO: change interface and implementation to fill log data in place
  and avoid one more memcpy/alloc between str and log string.
989 990
*/

991
const String *Item_param::query_val_str(String* str) const
992
{
993 994 995 996 997 998 999 1000
  switch (state) {
  case INT_VALUE:
    str->set(value.integer, &my_charset_bin);
    break;
  case REAL_VALUE:
    str->set(value.real, NOT_FIXED_DEC, &my_charset_bin);
    break;
  case TIME_VALUE:
1001
    {
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
      char *buf, *ptr;
      String tmp;
      str->length(0);
      /*
        TODO: in case of error we need to notify replication
        that binary log contains wrong statement 
      */
      if (str->reserve(MAX_DATE_REP_LENGTH+3))
        break; 

      /* Create date string inplace */
      buf= str->c_ptr_quick();
      ptr= buf;
      *ptr++= '\'';
      tmp.set(ptr, MAX_DATE_REP_LENGTH, &my_charset_bin);
      tmp.length(0);
      TIME_to_string(&value.time, &tmp);

      ptr+= tmp.length();
      *ptr++= '\'';
      str->length((uint32) (ptr - buf));
      break;
1024
    }
1025 1026
  case STRING_VALUE:
  case LONG_DATA_VALUE:
1027
    {
1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
      char *buf, *ptr;
      str->length(0);
      if (str->reserve(str_value.length()*2+3))
        break;

      buf= str->c_ptr_quick();
      ptr= buf;
      *ptr++= '\'';
      ptr+= escape_string_for_mysql(str_value.charset(), ptr,
                                    str_value.ptr(), str_value.length());
      *ptr++= '\'';
      str->length(ptr - buf);
      break;
1041
    }
1042 1043 1044 1045
  case NULL_VALUE:
    return &my_null_string;
  default:
    DBUG_ASSERT(0);
1046 1047 1048
  }
  return str;
}
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075


/*
  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 !=
        value.cs_info.character_set_client)
    {
      rc= thd->convert_string(&str_value,
                              value.cs_info.character_set_client,
                              value.cs_info.final_character_set_of_str_value);
    }
    max_length= str_value.length();
    decimals= 0;
1076 1077 1078 1079 1080 1081
    /*
      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());
1082 1083 1084 1085
  }
  return rc;
}

unknown's avatar
unknown committed
1086 1087
/* End of Item_param related */

1088

unknown's avatar
unknown committed
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
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)
{
1100
  // Item_copy_string is used without fix_fields call
unknown's avatar
unknown committed
1101 1102 1103 1104 1105
  if (null_value)
    return (String*) 0;
  return &str_value;
}

unknown's avatar
unknown committed
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115

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
1116
/*
1117
  Functions to convert item to field (for send_fields)
unknown's avatar
unknown committed
1118 1119 1120 1121
*/

/* ARGSUSED */
bool Item::fix_fields(THD *thd,
unknown's avatar
unknown committed
1122 1123
		      struct st_table_list *list,
		      Item ** ref)
unknown's avatar
unknown committed
1124
{
1125 1126

  // We do not check fields which are fixed during construction
unknown's avatar
unknown committed
1127
  DBUG_ASSERT(fixed == 0 || basic_const_item());
1128
  fixed= 1;
unknown's avatar
unknown committed
1129 1130 1131
  return 0;
}

1132 1133
double Item_ref_null_helper::val()
{
1134
  DBUG_ASSERT(fixed == 1);
1135
  double tmp= (*ref)->val_result();
unknown's avatar
unknown committed
1136
  owner->was_null|= null_value= (*ref)->null_value;
1137 1138
  return tmp;
}
1139 1140


1141 1142
longlong Item_ref_null_helper::val_int()
{
1143
  DBUG_ASSERT(fixed == 1);
1144
  longlong tmp= (*ref)->val_int_result();
unknown's avatar
unknown committed
1145
  owner->was_null|= null_value= (*ref)->null_value;
1146 1147
  return tmp;
}
1148 1149


1150 1151
String* Item_ref_null_helper::val_str(String* s)
{
1152
  DBUG_ASSERT(fixed == 1);
1153
  String* tmp= (*ref)->str_result(s);
unknown's avatar
unknown committed
1154
  owner->was_null|= null_value= (*ref)->null_value;
1155 1156
  return tmp;
}
1157 1158


1159
bool Item_ref_null_helper::get_date(TIME *ltime, uint fuzzydate)
1160 1161 1162
{  
  return (owner->was_null|= null_value= (*ref)->get_date(ltime, fuzzydate));
}
unknown's avatar
unknown committed
1163

unknown's avatar
unknown committed
1164 1165 1166 1167 1168 1169

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

  SYNOPSIS
    mark_as_dependent()
1170
    thd - thread handler
unknown's avatar
unknown committed
1171 1172 1173 1174 1175
    last - select from which current item depend
    current  - current select
    item - item which should be marked
*/

1176
static void mark_as_dependent(THD *thd, SELECT_LEX *last, SELECT_LEX *current,
unknown's avatar
unknown committed
1177 1178
			      Item_ident *item)
{
unknown's avatar
unknown committed
1179 1180 1181
  // store pointer on SELECT_LEX from wich item is dependent
  item->depended_from= last;
  current->mark_as_dependent(last);
1182
  if (thd->lex->describe & DESCRIBE_EXTENDED)
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
  {
    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
1193 1194 1195
}


unknown's avatar
unknown committed
1196
bool Item_field::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
unknown's avatar
unknown committed
1197
{
unknown's avatar
unknown committed
1198
  DBUG_ASSERT(fixed == 0);
1199
  if (!field)					// If field is not checked
unknown's avatar
unknown committed
1200
  {
1201
    TABLE_LIST *where= 0;
1202
    bool upward_lookup= 0;
1203
    Field *tmp= (Field *)not_found_field;
unknown's avatar
unknown committed
1204
    if ((tmp= find_field_in_tables(thd, this, tables, &where, 0)) ==
1205
	not_found_field)
1206 1207
    {
      /*
1208
	We can't find table field in table list of current select,
1209
	consequently we have to find it in outer subselect(s).
1210 1211 1212
	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
1213 1214 1215
	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
1216
      SELECT_LEX *last= 0;
unknown's avatar
unknown committed
1217 1218 1219
#ifdef EMBEDDED_LIBRARY
      thd->net.last_errno= 0;
#endif
1220
      TABLE_LIST *table_list;
1221
      Item **refer= (Item **)not_found_item;
1222
      uint counter;
1223
      // Prevent using outer fields in subselects, that is not supported now
1224
      SELECT_LEX *cursel= (SELECT_LEX *) thd->lex->current_select;
unknown's avatar
unknown committed
1225
      if (cursel->master_unit()->first_select()->linkage != DERIVED_TABLE_TYPE)
1226 1227 1228
      {
	SELECT_LEX_UNIT *prev_unit= cursel->master_unit();
	for (SELECT_LEX *sl= prev_unit->outer_select();
1229
	     sl;
1230
	     sl= (prev_unit= sl->master_unit())->outer_select())
1231
	{
1232
	  upward_lookup= 1;
1233
	  table_list= (last= sl)->get_table_list();
1234
	  if (sl->resolve_mode == SELECT_LEX::INSERT_MODE && table_list)
1235
	  {
1236 1237 1238 1239
            /*
              it is primary INSERT st_select_lex => skip first table
              resolving
            */
1240 1241
	    table_list= table_list->next;
	  }
unknown's avatar
unknown committed
1242 1243

	  Item_subselect *prev_subselect_item= prev_unit->item;
1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
          enum_parsing_place place=
            prev_subselect_item->parsing_place;
          /*
            check table fields only if subquery used somewhere out of HAVING
            or SELECT list or outer SELECT do not use groupping (i.e. tables
            are accessable)
          */
          if (((place != IN_HAVING &&
                place != SELECT_LIST) ||
               (sl->with_sum_func == 0 && sl->group_list.elements == 0)) &&
              (tmp= find_field_in_tables(thd, this,
                                         table_list, &where,
                                         0)) != not_found_field)
          {
            if (!tmp)
              return -1;
            prev_subselect_item->used_tables_cache|= tmp->table->map;
            prev_subselect_item->const_item_cache= 0;
            break;
          }
1264
	  if (sl->resolve_mode == SELECT_LEX::SELECT_MODE &&
1265 1266
	      (refer= find_item_in_list(this, sl->item_list, &counter,
					 REPORT_EXCEPT_NOT_FOUND)) !=
1267
	       (Item **) not_found_item)
1268 1269 1270
	  {
	    if (*refer && (*refer)->fixed) // Avoid crash in case of error
	    {
unknown's avatar
unknown committed
1271 1272
	      prev_subselect_item->used_tables_cache|= (*refer)->used_tables();
	      prev_subselect_item->const_item_cache&= (*refer)->const_item();
1273
	    }
1274
	    break;
1275 1276 1277
	  }

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

1281 1282
	  if (sl->master_unit()->first_select()->linkage ==
	      DERIVED_TABLE_TYPE)
1283
	    break; // do not look over derived table
1284
	}
1285
      }
1286
      if (!tmp)
1287
	return -1;
1288 1289 1290
      else if (!refer)
	return 1;
      else if (tmp == not_found_field && refer == (Item **)not_found_item)
unknown's avatar
unknown committed
1291
      {
1292
	if (upward_lookup)
unknown's avatar
unknown committed
1293
	{
1294 1295 1296
	  // 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
1297
	}
1298
	else
unknown's avatar
unknown committed
1299
	{
1300 1301
	  // Call to report error
	  find_field_in_tables(thd, this, tables, &where, 1);
unknown's avatar
unknown committed
1302
	}
unknown's avatar
unknown committed
1303 1304
	return -1;
      }
1305 1306
      else if (refer != (Item **)not_found_item)
      {
1307 1308 1309 1310 1311 1312 1313
	if (!(*refer)->fixed)
	{
	  my_error(ER_ILLEGAL_REFERENCE, MYF(0), name,
		   "forward reference in item list");
	  return -1;
	}

unknown's avatar
unknown committed
1314 1315
	Item_ref *rf;
	*ref= rf= new Item_ref(last->ref_pointer_array + counter,
unknown's avatar
unknown committed
1316
			       ref,
unknown's avatar
unknown committed
1317 1318
			       (char *)table_name,
			       (char *)field_name);
1319
	register_item_tree_changing(ref);
unknown's avatar
unknown committed
1320
	if (!rf)
1321
	  return 1;
1322 1323 1324 1325
	/*
	  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
1326
	if (rf->fix_fields(thd, tables, ref) || rf->check_cols(1))
unknown's avatar
unknown committed
1327
	  return 1;
unknown's avatar
unknown committed
1328

1329
	mark_as_dependent(thd, last, cursel, rf);
1330 1331
	return 0;
      }
1332
      else
unknown's avatar
unknown committed
1333
      {
1334
	mark_as_dependent(thd, last, cursel, this);
unknown's avatar
unknown committed
1335
	if (last->having_fix_field)
1336 1337
	{
	  Item_ref *rf;
1338
	  *ref= rf= new Item_ref(ref, *ref,
unknown's avatar
unknown committed
1339
				 (where->db[0]?where->db:0), 
1340 1341 1342 1343
				 (char *)where->alias,
				 (char *)field_name);
	  if (!rf)
	    return 1;
1344 1345 1346 1347
	  /*
	    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
1348
	  return rf->fix_fields(thd, tables, ref) ||  rf->check_cols(1);
1349
	}
unknown's avatar
unknown committed
1350
      }
1351
    }
1352 1353 1354
    else if (!tmp)
      return -1;

unknown's avatar
unknown committed
1355 1356
    set_field(tmp);
  }
unknown's avatar
unknown committed
1357
  else if (thd->set_query_id && field->query_id != thd->query_id)
1358 1359 1360 1361 1362
  {
    /* We only come here in unions */
    TABLE *table=field->table;
    field->query_id=thd->query_id;
    table->used_fields++;
1363
    table->used_keys.intersect(field->part_of_key);
1364
  }
1365
  fixed= 1;
unknown's avatar
unknown committed
1366 1367 1368
  return 0;
}

unknown's avatar
unknown committed
1369 1370
void Item_field::cleanup()
{
unknown's avatar
unknown committed
1371
  DBUG_ENTER("Item_field::cleanup");
unknown's avatar
unknown committed
1372
  Item_ident::cleanup();
1373 1374 1375 1376 1377
  /*
    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'.
   */
1378
  field= result_field= 0;
unknown's avatar
unknown committed
1379
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1380
}
unknown's avatar
unknown committed
1381 1382 1383

void Item::init_make_field(Send_field *tmp_field,
			   enum enum_field_types field_type)
1384
{
1385
  char *empty_name= (char*) "";
1386
  tmp_field->db_name=		empty_name;
1387 1388 1389 1390
  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;
1391
  tmp_field->charsetnr=         collation.collation->number;
unknown's avatar
unknown committed
1392 1393 1394 1395
  tmp_field->flags=maybe_null ? 0 : NOT_NULL_FLAG;
  tmp_field->type=field_type;
  tmp_field->length=max_length;
  tmp_field->decimals=decimals;
1396 1397
  if (unsigned_flag)
    tmp_field->flags |= UNSIGNED_FLAG;
unknown's avatar
unknown committed
1398 1399
}

1400
void Item::make_field(Send_field *tmp_field)
unknown's avatar
unknown committed
1401
{
1402
  init_make_field(tmp_field, field_type());
unknown's avatar
unknown committed
1403 1404 1405
}


1406 1407 1408 1409 1410
void Item_empty_string::make_field(Send_field *tmp_field)
{
  init_make_field(tmp_field,FIELD_TYPE_VAR_STRING);
}

unknown's avatar
unknown committed
1411

1412
enum_field_types Item::field_type() const
unknown's avatar
unknown committed
1413
{
1414 1415 1416
  return ((result_type() == STRING_RESULT) ? FIELD_TYPE_VAR_STRING :
	  (result_type() == INT_RESULT) ? FIELD_TYPE_LONGLONG :
	  FIELD_TYPE_DOUBLE);
unknown's avatar
unknown committed
1417 1418
}

1419

1420 1421
Field *Item::tmp_table_field_from_field_type(TABLE *table)
{
1422 1423 1424 1425 1426 1427
  /*
    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()) {
1428
  case MYSQL_TYPE_DECIMAL:
1429 1430
    return new Field_decimal((char*) 0, max_length, null_ptr, 0, Field::NONE,
			     name, table, decimals, 0, unsigned_flag);
1431
  case MYSQL_TYPE_TINY:
1432 1433
    return new Field_tiny((char*) 0, max_length, null_ptr, 0, Field::NONE,
			  name, table, 0, unsigned_flag);
1434
  case MYSQL_TYPE_SHORT:
1435 1436
    return new Field_short((char*) 0, max_length, null_ptr, 0, Field::NONE,
			   name, table, 0, unsigned_flag);
1437
  case MYSQL_TYPE_LONG:
1438 1439
    return new Field_long((char*) 0, max_length, null_ptr, 0, Field::NONE,
			  name, table, 0, unsigned_flag);
1440 1441
#ifdef HAVE_LONG_LONG
  case MYSQL_TYPE_LONGLONG:
1442 1443
    return new Field_longlong((char*) 0, max_length, null_ptr, 0, Field::NONE,
			      name, table, 0, unsigned_flag);
1444
#endif
1445 1446 1447 1448 1449 1450 1451 1452 1453
  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);
1454 1455
  case MYSQL_TYPE_NEWDATE:
  case MYSQL_TYPE_INT24:
1456 1457
    return new Field_medium((char*) 0, max_length, null_ptr, 0, Field::NONE,
			    name, table, 0, unsigned_flag);
1458 1459 1460 1461 1462 1463 1464 1465
  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:
1466 1467 1468 1469 1470 1471
    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 */
1472 1473
  case MYSQL_TYPE_ENUM:
  case MYSQL_TYPE_SET:
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483
  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);
1484 1485 1486 1487 1488
  case MYSQL_TYPE_TINY_BLOB:
  case MYSQL_TYPE_MEDIUM_BLOB:
  case MYSQL_TYPE_LONG_BLOB:
  case MYSQL_TYPE_BLOB:
  case MYSQL_TYPE_GEOMETRY:
1489
    break;					// Blob handled outside of case
1490
  }
1491 1492 1493 1494

  /* 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);
1495 1496
}

1497

1498 1499
/* ARGSUSED */
void Item_field::make_field(Send_field *tmp_field)
unknown's avatar
unknown committed
1500
{
1501
  field->make_field(tmp_field);
1502
  DBUG_ASSERT(tmp_field->table_name);
1503 1504
  if (name)
    tmp_field->col_name=name;			// Use user supplied name
unknown's avatar
unknown committed
1505 1506
}

1507

unknown's avatar
unknown committed
1508
/*
1509
  Set a field:s value from a item
unknown's avatar
unknown committed
1510 1511 1512 1513 1514 1515 1516
*/

void Item_field::save_org_in_field(Field *to)
{
  if (field->is_null())
  {
    null_value=1;
1517
    set_field_to_null_with_conversions(to, 1);
unknown's avatar
unknown committed
1518 1519 1520 1521 1522 1523 1524 1525 1526
  }
  else
  {
    to->set_notnull();
    field_conv(to,field);
    null_value=0;
  }
}

unknown's avatar
unknown committed
1527
int Item_field::save_in_field(Field *to, bool no_conversions)
unknown's avatar
unknown committed
1528 1529 1530 1531
{
  if (result_field->is_null())
  {
    null_value=1;
1532
    return set_field_to_null_with_conversions(to, no_conversions);
unknown's avatar
unknown committed
1533 1534 1535 1536 1537 1538 1539 1540 1541 1542
  }
  else
  {
    to->set_notnull();
    field_conv(to,result_field);
    null_value=0;
  }
  return 0;
}

1543

unknown's avatar
unknown committed
1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559
/*
  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
1560
int Item_null::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
1561
{
1562
  return set_field_to_null_with_conversions(field, no_conversions);
unknown's avatar
unknown committed
1563 1564 1565
}


1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577
/*
  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
1578
int Item_null::save_safe_in_field(Field *field)
unknown's avatar
unknown committed
1579 1580 1581 1582 1583
{
  return set_field_to_null(field);
}


unknown's avatar
unknown committed
1584
int Item::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
1585
{
1586
  int error;
unknown's avatar
unknown committed
1587 1588 1589 1590 1591
  if (result_type() == STRING_RESULT ||
      result_type() == REAL_RESULT &&
      field->result_type() == STRING_RESULT)
  {
    String *result;
1592
    CHARSET_INFO *cs= collation.collation;
unknown's avatar
unknown committed
1593
    char buff[MAX_FIELD_WIDTH];		// Alloc buffer for small columns
unknown's avatar
unknown committed
1594 1595
    str_value.set_quick(buff, sizeof(buff), cs);
    result=val_str(&str_value);
unknown's avatar
unknown committed
1596
    if (null_value)
1597
    {
unknown's avatar
unknown committed
1598
      str_value.set_quick(0, 0, cs);
1599
      return set_field_to_null_with_conversions(field, no_conversions);
1600
    }
unknown's avatar
unknown committed
1601
    field->set_notnull();
1602
    error=field->store(result->ptr(),result->length(),cs);
1603
    str_value.set_quick(0, 0, cs);
unknown's avatar
unknown committed
1604 1605 1606 1607 1608 1609 1610
  }
  else if (result_type() == REAL_RESULT)
  {
    double nr=val();
    if (null_value)
      return set_field_to_null(field);
    field->set_notnull();
1611
    error=field->store(nr);
unknown's avatar
unknown committed
1612 1613 1614 1615 1616
  }
  else
  {
    longlong nr=val_int();
    if (null_value)
1617
      return set_field_to_null_with_conversions(field, no_conversions);
unknown's avatar
unknown committed
1618
    field->set_notnull();
1619
    error=field->store(nr);
unknown's avatar
unknown committed
1620
  }
unknown's avatar
unknown committed
1621
  return error;
unknown's avatar
unknown committed
1622 1623
}

1624

unknown's avatar
unknown committed
1625
int Item_string::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
1626 1627 1628 1629 1630 1631
{
  String *result;
  result=val_str(&str_value);
  if (null_value)
    return set_field_to_null(field);
  field->set_notnull();
unknown's avatar
unknown committed
1632
  return field->store(result->ptr(),result->length(),collation.collation);
unknown's avatar
unknown committed
1633 1634
}

unknown's avatar
unknown committed
1635
int Item_uint::save_in_field(Field *field, bool no_conversions)
1636
{
1637 1638 1639 1640
  /*
    TODO: To be fixed when wen have a
    field->store(longlong, unsigned_flag) method 
  */
unknown's avatar
unknown committed
1641
  return Item_int::save_in_field(field, no_conversions);
1642 1643
}

unknown's avatar
unknown committed
1644 1645

int Item_int::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
1646 1647 1648 1649 1650
{
  longlong nr=val_int();
  if (null_value)
    return set_field_to_null(field);
  field->set_notnull();
unknown's avatar
unknown committed
1651
  return field->store(nr);
unknown's avatar
unknown committed
1652 1653
}

unknown's avatar
unknown committed
1654 1655 1656 1657
Item_num *Item_uint::neg()
{
  return new Item_real(name, - ((double) value), 0, max_length);
}
unknown's avatar
unknown committed
1658 1659

int Item_real::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
1660 1661 1662 1663 1664
{
  double nr=val();
  if (null_value)
    return set_field_to_null(field);
  field->set_notnull();
unknown's avatar
unknown committed
1665
  return field->store(nr);
unknown's avatar
unknown committed
1666 1667 1668 1669 1670 1671 1672 1673
}

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

unknown's avatar
unknown committed
1674
inline uint char_val(char X)
unknown's avatar
unknown committed
1675 1676 1677 1678 1679 1680
{
  return (uint) (X >= '0' && X <= '9' ? X-'0' :
		 X >= 'A' && X <= 'Z' ? X-'A'+10 :
		 X-'a'+10);
}

1681

1682
Item_varbinary::Item_varbinary(const char *str, uint str_length)
unknown's avatar
unknown committed
1683 1684 1685 1686 1687 1688
{
  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
1689
  str_value.set(ptr,max_length,&my_charset_bin);
unknown's avatar
unknown committed
1690 1691 1692 1693 1694 1695 1696 1697 1698
  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
1699
  collation.set(&my_charset_bin, DERIVATION_COERCIBLE);
unknown's avatar
unknown committed
1700
  fixed= 1;
unknown's avatar
unknown committed
1701 1702 1703 1704
}

longlong Item_varbinary::val_int()
{
unknown's avatar
unknown committed
1705
  // following assert is redundant, because fixed=1 assigned in constructor
1706
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
  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
1717
int Item_varbinary::save_in_field(Field *field, bool no_conversions)
unknown's avatar
unknown committed
1718
{
1719
  int error;
unknown's avatar
unknown committed
1720 1721 1722
  field->set_notnull();
  if (field->result_type() == STRING_RESULT)
  {
1723
    error=field->store(str_value.ptr(),str_value.length(),collation.collation);
unknown's avatar
unknown committed
1724 1725 1726 1727
  }
  else
  {
    longlong nr=val_int();
1728
    error=field->store(nr);
unknown's avatar
unknown committed
1729
  }
unknown's avatar
unknown committed
1730
  return error;
unknown's avatar
unknown committed
1731 1732 1733
}


1734 1735 1736 1737 1738
/*
  Pack data in buffer for sending
*/

bool Item_null::send(Protocol *protocol, String *packet)
unknown's avatar
unknown committed
1739
{
1740
  return protocol->store_null();
unknown's avatar
unknown committed
1741 1742 1743
}

/*
1744
  This is only called from items that is not of type item_field
unknown's avatar
unknown committed
1745 1746
*/

1747
bool Item::send(Protocol *protocol, String *buffer)
unknown's avatar
unknown committed
1748
{
1749 1750 1751 1752 1753 1754
  bool result;
  enum_field_types type;
  LINT_INIT(result);

  switch ((type=field_type())) {
  default:
1755 1756 1757 1758 1759 1760 1761 1762 1763
  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:
1764 1765 1766 1767 1768
  case MYSQL_TYPE_STRING:
  case MYSQL_TYPE_VAR_STRING:
  {
    String *res;
    if ((res=val_str(buffer)))
1769
      result= protocol->store(res->ptr(),res->length(),res->charset());
1770 1771 1772 1773
    break;
  }
  case MYSQL_TYPE_TINY:
  {
1774
    longlong nr;
1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787
    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;
  }
1788
  case MYSQL_TYPE_INT24:
1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804
  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
1805 1806 1807
  case MYSQL_TYPE_FLOAT:
  {
    float nr;
unknown's avatar
unknown committed
1808
    nr= (float) val();
unknown's avatar
unknown committed
1809 1810 1811 1812
    if (!null_value)
      result= protocol->store(nr, decimals, buffer);
    break;
  }
1813 1814 1815 1816 1817 1818 1819 1820 1821 1822
  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:
1823
  case MYSQL_TYPE_TIMESTAMP:
1824 1825
  {
    TIME tm;
1826
    get_date(&tm, TIME_FUZZY_DATE);
1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847
    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
1848 1849
}

1850 1851

bool Item_field::send(Protocol *protocol, String *buffer)
unknown's avatar
unknown committed
1852
{
1853
  return protocol->store(result_field);
unknown's avatar
unknown committed
1854 1855 1856 1857 1858 1859 1860
}

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

unknown's avatar
unknown committed
1861
bool Item_ref::fix_fields(THD *thd,TABLE_LIST *tables, Item **reference)
unknown's avatar
unknown committed
1862
{
1863
  DBUG_ASSERT(fixed == 0);
1864
  uint counter;
unknown's avatar
unknown committed
1865 1866
  if (!ref)
  {
1867
    TABLE_LIST *where= 0, *table_list;
1868
    bool upward_lookup= 0;
1869
    SELECT_LEX_UNIT *prev_unit= thd->lex->current_select->master_unit();
1870
    SELECT_LEX *sl= prev_unit->outer_select();
1871 1872 1873 1874 1875
    /*
      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
1876
    if ((ref= find_item_in_list(this, 
1877
				*(thd->lex->current_select->get_item_list()),
1878
				&counter,
1879
				((sl && 
1880
				  thd->lex->current_select->master_unit()->
1881
				  first_select()->linkage !=
1882 1883 1884
				  DERIVED_TABLE_TYPE) ? 
				  REPORT_EXCEPT_NOT_FOUND :
				  REPORT_ALL_ERRORS))) ==
unknown's avatar
unknown committed
1885
	(Item **)not_found_item)
unknown's avatar
unknown committed
1886
    {
1887
      upward_lookup= 1;
1888
      Field *tmp= (Field*) not_found_field;
unknown's avatar
unknown committed
1889
      /*
unknown's avatar
unknown committed
1890
	We can't find table field in table list of current select,
unknown's avatar
unknown committed
1891
	consequently we have to find it in outer subselect(s).
unknown's avatar
unknown committed
1892 1893 1894
	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
1895
	mention of table name, but if we join tables in one list it will
1896
	cause error ER_NON_UNIQ_ERROR in find_item_in_list.
unknown's avatar
unknown committed
1897 1898
      */
      SELECT_LEX *last=0;
1899
      for ( ; sl ; sl= (prev_unit= sl->master_unit())->outer_select())
1900
      {
1901
	last= sl;
unknown's avatar
unknown committed
1902
	Item_subselect *prev_subselect_item= prev_unit->item;
1903 1904
	if (sl->resolve_mode == SELECT_LEX::SELECT_MODE &&
	    (ref= find_item_in_list(this, sl->item_list,
1905 1906
				    &counter,
				    REPORT_EXCEPT_NOT_FOUND)) !=
unknown's avatar
unknown committed
1907
	   (Item **)not_found_item)
1908 1909 1910
	{
	  if (*ref && (*ref)->fixed) // Avoid crash in case of error
	  {
unknown's avatar
unknown committed
1911 1912
	    prev_subselect_item->used_tables_cache|= (*ref)->used_tables();
	    prev_subselect_item->const_item_cache&= (*ref)->const_item();
1913
	  }
1914
	  break;
1915
	}
1916
	table_list= sl->get_table_list();
1917
	if (sl->resolve_mode == SELECT_LEX::INSERT_MODE && table_list)
1918 1919 1920 1921
	{
	  // it is primary INSERT st_select_lex => skip first table resolving
	  table_list= table_list->next;
	}
1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940
        enum_parsing_place place=
            prev_subselect_item->parsing_place;
        /*
          check table fields only if subquery used somewhere out of HAVING
          or SELECT list or outer SELECT do not use groupping (i.e. tables
          are accessable)
        */
        if (((place != IN_HAVING &&
              place != SELECT_LIST) ||
             (sl->with_sum_func == 0 && sl->group_list.elements == 0)) &&
            (tmp= find_field_in_tables(thd, this,
                                       table_list, &where,
                                       0)) != not_found_field)
        {
          prev_subselect_item->used_tables_cache|= tmp->table->map;
          prev_subselect_item->const_item_cache= 0;
          break;
        }
        // Reference is not found => depend from outer (or just error)
unknown's avatar
unknown committed
1941 1942
	prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
	prev_subselect_item->const_item_cache= 0;
1943

1944 1945
	if (sl->master_unit()->first_select()->linkage ==
	    DERIVED_TABLE_TYPE)
1946
	  break; // do not look over derived table
1947
      }
1948

unknown's avatar
unknown committed
1949
      if (!ref)
1950
	return 1;
1951 1952 1953
      else if (!tmp)
	return -1;
      else if (ref == (Item **)not_found_item && tmp == not_found_field)
unknown's avatar
unknown committed
1954
      {
1955
	if (upward_lookup)
unknown's avatar
unknown committed
1956
	{
1957 1958 1959
	  // 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
1960
	}
1961
	else
unknown's avatar
unknown committed
1962
	{
1963 1964
	  // Call to report error
	  find_item_in_list(this,
1965
			    *(thd->lex->current_select->get_item_list()),
1966 1967
			    &counter,
			    REPORT_ALL_ERRORS);
unknown's avatar
unknown committed
1968
	}
1969
        ref= 0;
unknown's avatar
unknown committed
1970
	return 1;
unknown's avatar
unknown committed
1971
      }
1972 1973 1974
      else if (tmp != not_found_field)
      {
	ref= 0; // To prevent "delete *ref;" on ~Item_erf() of this item
unknown's avatar
unknown committed
1975
	Item_field* fld;
unknown's avatar
unknown committed
1976
	if (!((*reference)= fld= new Item_field(tmp)))
1977
	  return 1;
1978
	register_item_tree_changing(reference);
1979
	mark_as_dependent(thd, last, thd->lex->current_select, fld);
1980 1981
	return 0;
      }
unknown's avatar
unknown committed
1982 1983
      else
      {
1984 1985 1986 1987 1988 1989
	if (!(*ref)->fixed)
	{
	  my_error(ER_ILLEGAL_REFERENCE, MYF(0), name,
		   "forward reference in item list");
	  return -1;
	}
1990
	mark_as_dependent(thd, last, thd->lex->current_select,
unknown's avatar
unknown committed
1991 1992
			  this);
	ref= last->ref_pointer_array + counter;
unknown's avatar
unknown committed
1993 1994
      }
    }
1995
    else if (!ref)
unknown's avatar
unknown committed
1996
      return 1;
1997 1998 1999 2000 2001 2002 2003 2004
    else
    {
      if (!(*ref)->fixed)
      {
	my_error(ER_ILLEGAL_REFERENCE, MYF(0), name,
		 "forward reference in item list");
	return -1;
      }
2005
      ref= thd->lex->current_select->ref_pointer_array + counter;
2006
    }
unknown's avatar
unknown committed
2007
  }
2008

2009 2010 2011 2012 2013 2014 2015
  /*
    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.
  */
2016
  if (((*ref)->with_sum_func && name &&
2017
       (depended_from ||
2018 2019
	!(thd->lex->current_select->linkage != GLOBAL_OPTIONS_TYPE &&
	  thd->lex->current_select->having_fix_field))) ||
2020 2021 2022 2023 2024 2025 2026 2027
      !(*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;
  }
2028 2029 2030
  max_length= (*ref)->max_length;
  maybe_null= (*ref)->maybe_null;
  decimals=   (*ref)->decimals;
2031
  collation.set((*ref)->collation);
unknown's avatar
unknown committed
2032
  with_sum_func= (*ref)->with_sum_func;
2033
  fixed= 1;
2034

unknown's avatar
unknown committed
2035 2036
  if (ref && (*ref)->check_cols(1))
    return 1;
unknown's avatar
unknown committed
2037 2038 2039
  return 0;
}

2040

unknown's avatar
unknown committed
2041 2042
void Item_ref::cleanup()
{
unknown's avatar
unknown committed
2043
  DBUG_ENTER("Item_ref::cleanup");
unknown's avatar
unknown committed
2044 2045 2046
  Item_ident::cleanup();
  if (hook_ptr)
    *hook_ptr= orig_item;
unknown's avatar
unknown committed
2047
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2048 2049 2050
}


unknown's avatar
unknown committed
2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061
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)
{
2062
  str->append("<ref_null_helper>(", 18);
unknown's avatar
unknown committed
2063 2064 2065 2066 2067 2068 2069 2070 2071 2072
  if (ref && *ref)
    (*ref)->print(str);
  else
    str->append('?');
  str->append(')');
}


void Item_null_helper::print(String *str)
{
2073
  str->append("<null_helper>(", 14);
unknown's avatar
unknown committed
2074 2075 2076 2077 2078
  store->print(str);
  str->append(')');
}


unknown's avatar
SCRUM  
unknown committed
2079 2080
bool Item_default_value::eq(const Item *item, bool binary_cmp) const
{
unknown's avatar
SCRUM  
unknown committed
2081
  return item->type() == DEFAULT_VALUE_ITEM && 
unknown's avatar
SCRUM  
unknown committed
2082 2083 2084
    ((Item_default_value *)item)->arg->eq(arg, binary_cmp);
}

2085

2086 2087 2088
bool Item_default_value::fix_fields(THD *thd,
				    struct st_table_list *table_list,
				    Item **items)
unknown's avatar
SCRUM  
unknown committed
2089
{
2090
  DBUG_ASSERT(fixed == 0);
unknown's avatar
SCRUM  
unknown committed
2091
  if (!arg)
2092 2093
  {
    fixed= 1;
2094
    return 0;
2095
  }
2096 2097 2098
  if (arg->fix_fields(thd, table_list, &arg))
    return 1;
  
unknown's avatar
SCRUM  
unknown committed
2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112
  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
2113 2114
  def_field->move_field(def_field->table->default_values -
                        def_field->table->record[0]);
unknown's avatar
SCRUM  
unknown committed
2115
  set_field(def_field);
2116
  fixed= 1;
unknown's avatar
SCRUM  
unknown committed
2117 2118 2119
  return 0;
}

unknown's avatar
SCRUM  
unknown committed
2120 2121
void Item_default_value::print(String *str)
{
unknown's avatar
SCRUM  
unknown committed
2122 2123
  if (!arg)
  {
unknown's avatar
unknown committed
2124
    str->append("default", 7);
unknown's avatar
SCRUM  
unknown committed
2125
    return;
unknown's avatar
SCRUM  
unknown committed
2126
  }
unknown's avatar
unknown committed
2127
  str->append("default(", 8);
unknown's avatar
SCRUM  
unknown committed
2128 2129 2130
  arg->print(str);
  str->append(')');
}
2131

unknown's avatar
unknown committed
2132 2133 2134 2135 2136 2137 2138
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);
}


2139 2140 2141
bool Item_insert_value::fix_fields(THD *thd,
				   struct st_table_list *table_list,
				   Item **items)
unknown's avatar
unknown committed
2142
{
2143
  DBUG_ASSERT(fixed == 0);
2144 2145 2146
  if (arg->fix_fields(thd, table_list, &arg))
    return 1;

unknown's avatar
unknown committed
2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168
  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
  {
2169
    Field *tmp_field= field_arg->field;
unknown's avatar
unknown committed
2170
    /* charset doesn't matter here, it's to avoid sigsegv only */
2171 2172
    set_field(new Field_null(0, 0, Field::NONE, tmp_field->field_name,
			     tmp_field->table, &my_charset_bin));
unknown's avatar
unknown committed
2173
  }
2174
  fixed= 1;
unknown's avatar
unknown committed
2175 2176 2177 2178 2179
  return 0;
}

void Item_insert_value::print(String *str)
{
2180
  str->append("values(", 7);
unknown's avatar
unknown committed
2181 2182 2183 2184
  arg->print(str);
  str->append(')');
}

unknown's avatar
unknown committed
2185
/*
2186 2187
  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
2188 2189 2190 2191 2192 2193
*/

Item_result item_cmp_type(Item_result a,Item_result b)
{
  if (a == STRING_RESULT && b == STRING_RESULT)
    return STRING_RESULT;
2194
  if (a == INT_RESULT && b == INT_RESULT)
unknown's avatar
unknown committed
2195
    return INT_RESULT;
unknown's avatar
unknown committed
2196 2197
  else if (a == ROW_RESULT || b == ROW_RESULT)
    return ROW_RESULT;
2198
  return REAL_RESULT;
unknown's avatar
unknown committed
2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212
}


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
2213
    String tmp(buff,sizeof(buff),&my_charset_bin),*result;
unknown's avatar
unknown committed
2214 2215 2216 2217 2218
    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
2219
    return new Item_string(name,tmp_str,length,result->charset());
unknown's avatar
unknown committed
2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253
  }
  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
2254 2255
    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
2256 2257 2258
    item_result=item->val_str(&item_tmp);
    if (item->null_value)
      return 1;					// This must be true
2259
    field->val_str(&field_tmp);
unknown's avatar
unknown committed
2260
    return !stringcmp(&field_tmp,item_result);
unknown's avatar
unknown committed
2261 2262 2263 2264 2265 2266 2267 2268 2269
  }
  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();
}

2270 2271 2272 2273 2274 2275 2276 2277 2278 2279
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
2280 2281
  case ROW_RESULT:
    return new Item_cache_row();
2282 2283 2284 2285 2286 2287 2288
  default:
    // should never be in real life
    DBUG_ASSERT(0);
    return 0;
  }
}

unknown's avatar
unknown committed
2289 2290 2291

void Item_cache::print(String *str)
{
2292
  str->append("<cache>(", 8);
unknown's avatar
unknown committed
2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314
  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;
}


2315 2316
void Item_cache_str::store(Item *item)
{
unknown's avatar
merge  
unknown committed
2317
  value_buff.set(buffer, sizeof(buffer), item->collation.collation);
2318
  value= item->str_result(&value_buff);
2319 2320
  if ((null_value= item->null_value))
    value= 0;
2321
  else if (value != &value_buff)
2322 2323 2324 2325 2326 2327 2328 2329 2330
  {
    /*
      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;
    */
2331 2332
    value_buff.copy(*value);
    value= &value_buff;
2333 2334
  }
}
2335 2336


2337
double Item_cache_str::val()
2338 2339
{
  DBUG_ASSERT(fixed == 1);
2340
  int err;
2341
  if (value)
2342
    return my_strntod(value->charset(), (char*) value->ptr(),
2343
		      value->length(), (char**) 0, &err);
2344 2345 2346
  else
    return (double)0;
}
2347 2348


2349 2350
longlong Item_cache_str::val_int()
{
2351
  DBUG_ASSERT(fixed == 1);
2352
  int err;
2353 2354
  if (value)
    return my_strntoll(value->charset(), value->ptr(),
2355
		       value->length(), 10, (char**) 0, &err);
2356 2357 2358
  else
    return (longlong)0;
}
unknown's avatar
unknown committed
2359

2360

unknown's avatar
unknown committed
2361 2362
bool Item_cache_row::allocate(uint num)
{
unknown's avatar
unknown committed
2363
  item_count= num;
unknown's avatar
unknown committed
2364
  THD *thd= current_thd;
unknown's avatar
unknown committed
2365 2366
  return (!(values= 
	    (Item_cache **) thd->calloc(sizeof(Item_cache *)*item_count)));
unknown's avatar
unknown committed
2367 2368
}

2369

unknown's avatar
unknown committed
2370 2371
bool Item_cache_row::setup(Item * item)
{
unknown's avatar
unknown committed
2372
  example= item;
unknown's avatar
unknown committed
2373 2374
  if (!values && allocate(item->cols()))
    return 1;
unknown's avatar
unknown committed
2375
  for (uint i= 0; i < item_count; i++)
unknown's avatar
unknown committed
2376
  {
unknown's avatar
unknown committed
2377
    Item *el= item->el(i);
unknown's avatar
unknown committed
2378 2379
    Item_cache *tmp;
    if (!(tmp= values[i]= Item_cache::get_cache(el->result_type())))
unknown's avatar
unknown committed
2380
      return 1;
unknown's avatar
unknown committed
2381
    tmp->setup(el);
unknown's avatar
unknown committed
2382 2383 2384 2385
  }
  return 0;
}

2386

unknown's avatar
unknown committed
2387 2388 2389 2390
void Item_cache_row::store(Item * item)
{
  null_value= 0;
  item->bring_value();
unknown's avatar
unknown committed
2391
  for (uint i= 0; i < item_count; i++)
unknown's avatar
unknown committed
2392 2393 2394 2395 2396 2397
  {
    values[i]->store(item->el(i));
    null_value|= values[i]->null_value;
  }
}

2398

unknown's avatar
unknown committed
2399 2400 2401 2402 2403
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
2404
  my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
unknown's avatar
unknown committed
2405 2406 2407
  DBUG_VOID_RETURN;
}

2408

unknown's avatar
unknown committed
2409 2410
bool Item_cache_row::check_cols(uint c)
{
unknown's avatar
unknown committed
2411
  if (c != item_count)
unknown's avatar
unknown committed
2412
  {
unknown's avatar
unknown committed
2413
    my_error(ER_OPERAND_COLUMNS, MYF(0), c);
unknown's avatar
unknown committed
2414 2415 2416 2417 2418
    return 1;
  }
  return 0;
}

2419

unknown's avatar
unknown committed
2420 2421
bool Item_cache_row::null_inside()
{
unknown's avatar
unknown committed
2422
  for (uint i= 0; i < item_count; i++)
unknown's avatar
unknown committed
2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438
  {
    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;
}

2439

unknown's avatar
unknown committed
2440 2441
void Item_cache_row::bring_value()
{
unknown's avatar
unknown committed
2442
  for (uint i= 0; i < item_count; i++)
unknown's avatar
unknown committed
2443 2444 2445
    values[i]->bring_value();
  return;
}
unknown's avatar
unknown committed
2446

2447 2448

Item_type_holder::Item_type_holder(THD *thd, Item *item)
2449 2450
  :Item(thd, item), item_type(item->result_type()),
   orig_type(item_type)
2451 2452
{
  DBUG_ASSERT(item->fixed);
unknown's avatar
unknown committed
2453 2454 2455 2456 2457

  /*
    It is safe assign pointer on field, because it will be used just after
    all JOIN::prepare calls and before any SELECT execution
  */
2458
  if (item->type() == Item::FIELD_ITEM)
unknown's avatar
unknown committed
2459
    field_example= ((Item_field*) item)->field;
2460 2461
  else
    field_example= 0;
2462
  max_length= real_length(item);
2463
  collation.set(item->collation);
2464 2465 2466
}


2467 2468 2469 2470 2471 2472 2473
/*
  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)
*/
2474 2475 2476 2477 2478 2479
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}};

2480
bool Item_type_holder::join_types(THD *thd, Item *item)
2481
{
2482
  uint32 new_length= real_length(item);
2483 2484 2485 2486 2487 2488 2489
  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
2490
    if (field_example->field_cast_type() != field->field_cast_type())
2491
    {
unknown's avatar
unknown committed
2492 2493 2494 2495 2496 2497 2498 2499 2500 2501
      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;
      }
2502 2503 2504 2505 2506 2507
    }
  }

  // size/type should be changed
  if (change_field ||
      (new_type != item_type) ||
2508
      (max_length < new_length) ||
2509 2510
      ((new_type == INT_RESULT) &&
       (decimals < item->decimals)) ||
2511 2512 2513
      (!maybe_null && item->maybe_null) ||
      (item_type == STRING_RESULT && new_type == STRING_RESULT &&
       !my_charset_same(collation.collation, item->collation.collation)))
2514 2515 2516
  {
    // new field has some parameters worse then current
    skip_store_field|= (change_field &&
2517
			(max_length > new_length) ||
2518 2519
			((new_type == INT_RESULT) &&
			 (decimals > item->decimals)) ||
2520 2521 2522 2523 2524
			(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
2525 2526 2527 2528
    /*
      It is safe assign pointer on field, because it will be used just after
      all JOIN::prepare calls and before any SELECT execution
    */
2529 2530 2531
    if (skip_store_field || item->type() != Item::FIELD_ITEM)
      field_example= 0;
    else
unknown's avatar
unknown committed
2532 2533
      field_example= ((Item_field*) item)->field;

2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545
    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;
    }

2546
    max_length= max(max_length, new_length);
2547 2548 2549 2550 2551
    decimals= max(decimals, item->decimals);
    maybe_null|= item->maybe_null;
    item_type= new_type;
  }
  DBUG_ASSERT(item_type != ROW_RESULT);
2552
  return 0;
2553 2554
}

2555 2556 2557 2558
uint32 Item_type_holder::real_length(Item *item)
{
  if (item->type() == Item::FIELD_ITEM)
  {
unknown's avatar
unknown committed
2559
    return ((Item_field *)item)->max_disp_length();
2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574
  }
  switch (item->result_type())
  {
  case STRING_RESULT:
    return item->max_length;
  case REAL_RESULT:
    return 53;
  case INT_RESULT:
    return 20;
  case ROW_RESULT:
  default:
    DBUG_ASSERT(0); // we should never go there
    return 0;
  }
}
2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595

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
2596 2597 2598 2599 2600 2601 2602
/*****************************************************************************
** Instantiate templates
*****************************************************************************/

#ifdef __GNUC__
template class List<Item>;
template class List_iterator<Item>;
unknown's avatar
unknown committed
2603
template class List_iterator_fast<Item>;
unknown's avatar
unknown committed
2604 2605
template class List<List_item>;
#endif