item.h 31 KB
Newer Older
1
/* Copyright (C) 2000-2003 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
   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 interface			/* gcc class implementation */
#endif

22
class Protocol;
unknown's avatar
unknown committed
23
struct st_table_list;
unknown's avatar
unknown committed
24
void item_init(void);			/* Init item functions */
unknown's avatar
unknown committed
25

26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

/*
   "Declared Type Collation"
   A combination of collation and its deriviation.
*/

enum Derivation
{
  DERIVATION_COERCIBLE= 3,
  DERIVATION_IMPLICIT= 2,
  DERIVATION_NONE= 1,
  DERIVATION_EXPLICIT= 0
};

class DTCollation {
public:
  CHARSET_INFO     *collation;
  enum Derivation derivation;
  
  DTCollation()
  {
    collation= &my_charset_bin;
    derivation= DERIVATION_NONE;
  }
  DTCollation(CHARSET_INFO *collation_arg, Derivation derivation_arg)
  {
    collation= collation_arg;
    derivation= derivation_arg;
  }
55
  void set(DTCollation &dt)
56
  { 
57 58
    collation= dt.collation;
    derivation= dt.derivation;
59 60 61 62 63 64 65 66 67 68
  }
  void set(CHARSET_INFO *collation_arg, Derivation derivation_arg)
  {
    collation= collation_arg;
    derivation= derivation_arg;
  }
  void set(CHARSET_INFO *collation_arg)
  { collation= collation_arg; }
  void set(Derivation derivation_arg)
  { derivation= derivation_arg; }
69 70 71
  bool aggregate(DTCollation &dt);
  bool set(DTCollation &dt1, DTCollation &dt2)
  { set(dt1); return aggregate(dt2); }
72 73 74 75 76 77 78 79 80 81 82 83 84
  const char *derivation_name() const
  {
    switch(derivation)
    {
      case DERIVATION_COERCIBLE: return "COERCIBLE";
      case DERIVATION_IMPLICIT:  return "IMPLICIT";
      case DERIVATION_EXPLICIT:  return "EXPLICIT";
      case DERIVATION_NONE:      return "NONE";
      default: return "UNKNOWN";
    }
  }
};

unknown's avatar
unknown committed
85 86
typedef bool (Item::*Item_processor)(byte *arg);

unknown's avatar
unknown committed
87
class Item {
unknown's avatar
unknown committed
88
  Item(const Item &);			/* Prevent use of these */
unknown's avatar
unknown committed
89 90
  void operator=(Item &);
public:
unknown's avatar
unknown committed
91
  static void *operator new(size_t size) {return (void*) sql_alloc((uint) size); }
92 93
  static void *operator new(size_t size, MEM_ROOT *mem_root)
  { return (void*) alloc_root(mem_root, (uint) size); }
unknown's avatar
unknown committed
94 95
  static void operator delete(void *ptr,size_t size) {} /*lint -e715 */

96 97
  enum Type {FIELD_ITEM, FUNC_ITEM, SUM_FUNC_ITEM, STRING_ITEM,
	     INT_ITEM, REAL_ITEM, NULL_ITEM, VARBIN_ITEM,
unknown's avatar
SCRUM  
unknown committed
98
	     COPY_STR_ITEM, FIELD_AVG_ITEM, DEFAULT_VALUE_ITEM,
unknown's avatar
unknown committed
99 100
	     PROC_ITEM,COND_ITEM, REF_ITEM, FIELD_STD_ITEM,
	     FIELD_VARIANCE_ITEM, INSERT_VALUE_ITEM,
101
             SUBSELECT_ITEM, ROW_ITEM, CACHE_ITEM};
unknown's avatar
SCRUM  
unknown committed
102

unknown's avatar
unknown committed
103
  enum cond_result { COND_UNDEF,COND_OK,COND_TRUE,COND_FALSE };
104
  
unknown's avatar
unknown committed
105 106 107 108
  String str_value;			/* used to store value */
  my_string name;			/* Name from select */
  Item *next;
  uint32 max_length;
109
  uint name_length;                     /* Length of name */
unknown's avatar
unknown committed
110 111 112
  uint8 marker,decimals;
  my_bool maybe_null;			/* If item may be null */
  my_bool null_value;			/* if item is null */
113
  my_bool unsigned_flag;
unknown's avatar
unknown committed
114
  my_bool with_sum_func;
115
  my_bool fixed;                        /* If item fixed with fix_fields */
116
  DTCollation collation;
117

unknown's avatar
unknown committed
118 119
  // alloc & destruct is done as start of select using sql_alloc
  Item();
120 121 122 123
  /*
     Constructor used by Item_field, Item_ref & agregate (sum) functions.
     Used for duplicating lists in processing queries with temporary
     tables
124 125 126
     Also it used for Item_cond_and/Item_cond_or for creating
     top AND/OR ctructure of WHERE clause to protect it of
     optimisation changes in prepared statements
127
  */
128
  Item(THD *thd, Item &item);
129
  virtual ~Item() { name=0; cleanup(); }		/*lint -e1509 */
unknown's avatar
unknown committed
130
  void set_name(const char *str,uint length, CHARSET_INFO *cs);
unknown's avatar
unknown committed
131
  void init_make_field(Send_field *tmp_field,enum enum_field_types type);
132
  virtual void cleanup() {}
133
  virtual void make_field(Send_field *field);
unknown's avatar
unknown committed
134
  virtual bool fix_fields(THD *, struct st_table_list *, Item **);
unknown's avatar
unknown committed
135
  virtual int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
136
  virtual void save_org_in_field(Field *field)
137
  { (void) save_in_field(field, 1); }
unknown's avatar
unknown committed
138
  virtual int save_safe_in_field(Field *field)
139
  { return save_in_field(field, 1); }
140
  virtual bool send(Protocol *protocol, String *str);
141
  virtual bool eq(const Item *, bool binary_cmp) const;
unknown's avatar
unknown committed
142
  virtual Item_result result_type () const { return REAL_RESULT; }
143
  virtual enum_field_types field_type() const;
unknown's avatar
unknown committed
144 145 146 147
  virtual enum Type type() const =0;
  virtual double val()=0;
  virtual longlong val_int()=0;
  virtual String *val_str(String*)=0;
148
  virtual Field *get_tmp_table_field() { return 0; }
149
  virtual Field *tmp_table_field(TABLE *t_arg) { return 0; }
unknown's avatar
unknown committed
150 151 152 153
  virtual const char *full_name() const { return name ? name : "???"; }
  virtual double  val_result() { return val(); }
  virtual longlong val_int_result() { return val_int(); }
  virtual String *str_result(String* tmp) { return val_str(tmp); }
154
  /* bit map of tables used by item */
unknown's avatar
unknown committed
155
  virtual table_map used_tables() const { return (table_map) 0L; }
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
  /*
    Return table map of tables that can't be NULL tables (tables that are
    used in a context where if they would contain a NULL row generated
    by a LEFT or RIGHT join, the item would not be true).
    This expression is used on WHERE item to determinate if a LEFT JOIN can be
    converted to a normal join.
    Generally this function should return used_tables() if the function
    would return null if any of the arguments are null
    As this is only used in the beginning of optimization, the value don't
    have to be updated in update_used_tables()
  */
  virtual table_map not_null_tables() const { return used_tables(); }
  /*
    Returns true if this is a simple constant item like an integer, not
    a constant expression
  */
unknown's avatar
unknown committed
172 173 174 175 176 177 178
  virtual bool basic_const_item() const { return 0; }
  virtual Item *new_item() { return 0; }	/* Only for const items */
  virtual cond_result eq_cmp_result() const { return COND_OK; }
  inline uint float_length(uint decimals_par) const
  { return decimals != NOT_FIXED_DEC ? (DBL_DIG+2+decimals_par) : DBL_DIG+8;}
  virtual bool const_item() const { return used_tables() == 0; }
  virtual void print(String *str_arg) { str_arg->append(full_name()); }
unknown's avatar
unknown committed
179
  void print_item_w_name(String *);
unknown's avatar
unknown committed
180
  virtual void update_used_tables() {}
181
  virtual void split_sum_func(Item **ref_pointer_array, List<Item> &fields) {}
182
  virtual bool get_date(TIME *ltime,uint fuzzydate);
unknown's avatar
unknown committed
183
  virtual bool get_time(TIME *ltime);
184
  virtual bool get_date_result(TIME *ltime,uint fuzzydate)
185
  { return get_date(ltime,fuzzydate); }
186
  virtual bool is_null() { return 0; }
187
  virtual void top_level_item() {}
unknown's avatar
unknown committed
188 189 190
  virtual void set_result_field(Field *field) {}
  virtual bool is_result_field() { return 0; }
  virtual void save_in_result_field(bool no_conversions) {}
unknown's avatar
unknown committed
191
  virtual void no_rows_in_result() {}
192
  virtual Item *copy_or_same(THD *thd) { return this; }
193
  virtual Item *copy_andor_structure(THD *thd) { return this; }
unknown's avatar
unknown committed
194
  virtual Item *real_item() { return this; }
195
  virtual Item *get_tmp_table_item(THD *thd) { return copy_or_same(thd); }
unknown's avatar
unknown committed
196

197
  CHARSET_INFO *default_charset() const;
unknown's avatar
unknown committed
198 199 200 201 202 203 204

  virtual bool walk(Item_processor processor, byte *arg)
  {
    return (this->*processor)(arg);
  }

  virtual bool remove_dependence_processor(byte * arg) { return 0; }
205
  virtual bool remove_fixed(byte * arg) { fixed= 0; return 0; }
206
  
207 208
  virtual Item *this_item() { return this; } /* For SPs mostly. */
  virtual Item *this_const_item() const { return const_cast<Item*>(this); } /* For SPs mostly. */
unknown's avatar
unknown committed
209 210 211 212

  // Row emulation
  virtual uint cols() { return 1; }
  virtual Item* el(uint i) { return this; }
213
  virtual Item** addr(uint i) { return 0; }
unknown's avatar
unknown committed
214
  virtual bool check_cols(uint c);
unknown's avatar
unknown committed
215
  // It is not row => null inside is impossible
216 217 218
  virtual bool null_inside() { return 0; }
  // used in row subselects to get value of elements
  virtual void bring_value() {}
219 220

  Field *tmp_table_field_from_field_type(TABLE *table);
221 222 223
  
  /* Used in sql_select.cc:eliminate_not_funcs() */
  virtual Item *neg_transformer() { return NULL; }
unknown's avatar
unknown committed
224 225 226
};


227 228 229 230 231 232 233 234 235 236 237
// A local SP variable (incl. parameters), used in runtime
class Item_splocal : public Item
{
private:
  
  uint m_offset;

public:

  Item_splocal(uint offset)
    : m_offset(offset)
238 239 240
  {
    Item::maybe_null= TRUE;
  }
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276

  Item *this_item();
  Item *this_const_item() const;

  inline uint get_offset()
  {
    return m_offset;
  }

  // Abstract methods inherited from Item. Just defer the call to
  // the item in the frame
  inline enum Type type() const
  {
    return this_const_item()->type();
  }

  inline double val()
  {
    return this_item()->val();
  }

  inline longlong val_int()
  {
    return this_item()->val_int();
  }

  inline String *val_str(String *sp)
  {
    return this_item()->val_str(sp);
  }

  inline void make_field(Send_field *field)
  {
    this_item()->make_field(field);
  }

277 278 279 280 281 282 283 284 285 286
  inline Item_result result_type() const
  {
    return this_const_item()->result_type();
  }

  inline bool const_item() const
  {
    return FALSE;
  }

287 288 289 290
  inline int save_in_field(Field *field, bool no_conversions)
  {
    return this_item()->save_in_field(field, no_conversions);
  }
291 292 293
};


unknown's avatar
unknown committed
294
class st_select_lex;
unknown's avatar
unknown committed
295 296 297 298 299 300
class Item_ident :public Item
{
public:
  const char *db_name;
  const char *table_name;
  const char *field_name;
unknown's avatar
unknown committed
301
  st_select_lex *depended_from;
unknown's avatar
unknown committed
302 303
  Item_ident(const char *db_name_par,const char *table_name_par,
	     const char *field_name_par)
304
    :db_name(db_name_par), table_name(table_name_par),
unknown's avatar
unknown committed
305
     field_name(field_name_par), depended_from(0)
unknown's avatar
unknown committed
306
    { name = (char*) field_name_par; }
307 308
  // Constructor used by Item_field & Item_ref (see Item comment)
  Item_ident(THD *thd, Item_ident &item);
unknown's avatar
unknown committed
309
  const char *full_name() const;
unknown's avatar
unknown committed
310 311

  bool remove_dependence_processor(byte * arg);
unknown's avatar
unknown committed
312 313
};

unknown's avatar
unknown committed
314

unknown's avatar
unknown committed
315 316 317 318 319 320 321 322 323 324
class Item_field :public Item_ident
{
  void set_field(Field *field);
public:
  Field *field,*result_field;
  // Item_field() {}

  Item_field(const char *db_par,const char *table_name_par,
	     const char *field_name_par)
    :Item_ident(db_par,table_name_par,field_name_par),field(0),result_field(0)
325
  { collation.set(DERIVATION_IMPLICIT); }
326 327
  // Constructor need to process subselect with temporary tables (see Item)
  Item_field(THD *thd, Item_field &item);
unknown's avatar
unknown committed
328 329
  Item_field(Field *field);
  enum Type type() const { return FIELD_ITEM; }
330
  bool eq(const Item *item, bool binary_cmp) const;
unknown's avatar
unknown committed
331 332 333 334 335 336
  double val();
  longlong val_int();
  String *val_str(String*);
  double val_result();
  longlong val_int_result();
  String *str_result(String* tmp);
337
  bool send(Protocol *protocol, String *str_arg);
unknown's avatar
unknown committed
338
  bool fix_fields(THD *, struct st_table_list *, Item **);
339
  void make_field(Send_field *tmp_field);
unknown's avatar
unknown committed
340
  int save_in_field(Field *field,bool no_conversions);
unknown's avatar
unknown committed
341 342 343 344 345 346
  void save_org_in_field(Field *field);
  table_map used_tables() const;
  enum Item_result result_type () const
  {
    return field->result_type();
  }
unknown's avatar
unknown committed
347
  enum_field_types field_type() const
348 349 350
  {
    return field->type();
  }
351
  Field *get_tmp_table_field() { return result_field; }
352
  Field *tmp_table_field(TABLE *t_arg) { return result_field; }
353 354
  bool get_date(TIME *ltime,uint fuzzydate);
  bool get_date_result(TIME *ltime,uint fuzzydate);
355
  bool get_time(TIME *ltime);
unknown's avatar
unknown committed
356
  bool is_null() { return field->is_null(); }
357
  Item *get_tmp_table_item(THD *thd);
unknown's avatar
SCRUM  
unknown committed
358
  friend class Item_default_value;
unknown's avatar
unknown committed
359
  friend class Item_insert_value;
unknown's avatar
unknown committed
360 361 362 363 364 365 366 367
};

class Item_null :public Item
{
public:
  Item_null(char *name_par=0)
    { maybe_null=null_value=TRUE; name= name_par ? name_par : (char*) "NULL";}
  enum Type type() const { return NULL_ITEM; }
368
  bool eq(const Item *item, bool binary_cmp) const;
unknown's avatar
unknown committed
369 370 371
  double val();
  longlong val_int();
  String *val_str(String *str);
unknown's avatar
unknown committed
372
  int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
373
  int save_safe_in_field(Field *field);
unknown's avatar
unknown committed
374
  bool send(Protocol *protocol, String *str);
375 376 377 378 379 380 381 382
  enum Item_result result_type () const { return STRING_RESULT; }
  enum_field_types field_type() const   { return MYSQL_TYPE_NULL; }
  bool fix_fields(THD *thd, struct st_table_list *list, Item **item)
  {
    bool res= Item::fix_fields(thd, list, item);
    max_length=0;
    return res;
  }
unknown's avatar
unknown committed
383 384
  bool basic_const_item() const { return 1; }
  Item *new_item() { return new Item_null(name); }
unknown's avatar
unknown committed
385
  bool is_null() { return 1; }
386
  void print(String *str) { str->append("NULL", 4); }
unknown's avatar
unknown committed
387 388
};

unknown's avatar
unknown committed
389 390 391 392 393
class Item_param :public Item
{
public:    
  longlong int_value;
  double   real_value;
394
  TIME     ltime;
unknown's avatar
unknown committed
395 396 397
  enum Item_result item_result_type;
  enum Type item_type;
  enum enum_field_types buffer_type;
398
  bool item_is_time;
399 400
  bool long_data_supplied;
  uint pos_in_query;
unknown's avatar
unknown committed
401

402
  Item_param(uint position)
403
  { 
404 405
    name= (char*) "?";
    pos_in_query= position;
unknown's avatar
unknown committed
406
    item_type= STRING_ITEM;
407
    item_result_type = STRING_RESULT;
408
    item_is_time= false;
409
    long_data_supplied= false;
unknown's avatar
unknown committed
410 411 412 413 414
  }
  enum Type type() const { return item_type; }
  double val();
  longlong val_int();
  String *val_str(String*);
unknown's avatar
unknown committed
415
  int  save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
416 417 418
  void set_null();
  void set_int(longlong i);
  void set_double(double i);
unknown's avatar
unknown committed
419 420 421 422
  void set_value(const char *str, uint length);
  void set_long_str(const char *str, ulong length);
  void set_long_binary(const char *str, ulong length);
  void set_longdata(const char *str, ulong length);
unknown's avatar
unknown committed
423
  void set_long_end();
424 425
  void set_time(TIME *tm, timestamp_type type);
  bool get_time(TIME *tm);
426
  void reset() {}
unknown's avatar
unknown committed
427
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
428
  void (*setup_param_func)(Item_param *param, uchar **pos);
unknown's avatar
unknown committed
429 430 431
#else
  void (*setup_param_func)(Item_param *param, uchar **pos, ulong data_len);
#endif
unknown's avatar
unknown committed
432
  enum Item_result result_type () const
unknown's avatar
unknown committed
433
  { return item_result_type; }
434
  String *query_val_str(String *str);
435
  enum_field_types field_type() const { return MYSQL_TYPE_STRING; }
436
  Item *new_item() { return new Item_param(pos_in_query); }
unknown's avatar
unknown committed
437
  void print(String *str) { str->append('?'); }
unknown's avatar
unknown committed
438
};
unknown's avatar
unknown committed
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454

class Item_int :public Item
{
public:
  const longlong value;
  Item_int(int32 i,uint length=11) :value((longlong) i)
    { max_length=length;}
#ifdef HAVE_LONG_LONG
  Item_int(longlong i,uint length=21) :value(i)
    { max_length=length;}
#endif
  Item_int(const char *str_arg,longlong i,uint length) :value(i)
    { max_length=length; name=(char*) str_arg;}
  Item_int(const char *str_arg) :
    value(str_arg[0] == '-' ? strtoll(str_arg,(char**) 0,10) :
	  (longlong) strtoull(str_arg,(char**) 0,10))
unknown's avatar
unknown committed
455
    { max_length= (uint) strlen(str_arg); name=(char*) str_arg;}
unknown's avatar
unknown committed
456
  enum Type type() const { return INT_ITEM; }
457 458
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types field_type() const { return MYSQL_TYPE_LONGLONG; }
unknown's avatar
unknown committed
459 460 461
  longlong val_int() { return value; }
  double val() { return (double) value; }
  String *val_str(String*);
unknown's avatar
unknown committed
462
  int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
463 464 465 466 467 468
  bool basic_const_item() const { return 1; }
  Item *new_item() { return new Item_int(name,value,max_length); }
  void print(String *str);
};


unknown's avatar
unknown committed
469 470 471 472 473
class Item_uint :public Item_int
{
public:
  Item_uint(const char *str_arg, uint length) :
    Item_int(str_arg, (longlong) strtoull(str_arg,(char**) 0,10), length) {}
unknown's avatar
unknown committed
474
  Item_uint(uint32 i) :Item_int((longlong) i, 10) {}
475
  double val() { return ulonglong2double((ulonglong)value); }
unknown's avatar
unknown committed
476 477
  String *val_str(String*);
  Item *new_item() { return new Item_uint(name,max_length); }
478 479 480 481 482 483
  bool fix_fields(THD *thd, struct st_table_list *list, Item **item)
  {
    bool res= Item::fix_fields(thd, list, item);
    unsigned_flag= 1;
    return res;
  }
unknown's avatar
unknown committed
484 485 486 487
  void print(String *str);
};


unknown's avatar
unknown committed
488 489 490 491 492 493 494 495
class Item_real :public Item
{
public:
  const double value;
  // Item_real() :value(0) {}
  Item_real(const char *str_arg,uint length) :value(atof(str_arg))
  {
    name=(char*) str_arg;
unknown's avatar
unknown committed
496
    decimals=(uint8) nr_of_decimals(str_arg);
unknown's avatar
unknown committed
497 498 499 500 501 502
    max_length=length;
  }
  Item_real(const char *str,double val_arg,uint decimal_par,uint length)
    :value(val_arg)
  {
    name=(char*) str;
unknown's avatar
unknown committed
503
    decimals=(uint8) decimal_par;
unknown's avatar
unknown committed
504 505 506
    max_length=length;
  }
  Item_real(double value_par) :value(value_par) {}
unknown's avatar
unknown committed
507
  int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
508
  enum Type type() const { return REAL_ITEM; }
509
  enum_field_types field_type() const { return MYSQL_TYPE_DOUBLE; }
unknown's avatar
unknown committed
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
  double val() { return value; }
  longlong val_int() { return (longlong) (value+(value > 0 ? 0.5 : -0.5));}
  String *val_str(String*);
  bool basic_const_item() const { return 1; }
  Item *new_item() { return new Item_real(name,value,decimals,max_length); }
};


class Item_float :public Item_real
{
public:
  Item_float(const char *str,uint length) :Item_real(str,length)
  {
    decimals=NOT_FIXED_DEC;
    max_length=DBL_DIG+8;
  }
};

class Item_string :public Item
{
public:
unknown's avatar
unknown committed
531
  Item_string(const char *str,uint length,
532
  	      CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE)
unknown's avatar
unknown committed
533
  {
534
    collation.set(cs, dv);
535
    str_value.set(str,length,cs);
536 537 538 539 540 541 542
    /*
      We have to have a different max_length than 'length' here to
      ensure that we get the right length if we do use the item
      to create a new table. In this case max_length must be the maximum
      number of chars for a string of this type because we in create_field::
      divide the max_length with mbmaxlen).
    */
543
    max_length= str_value.numchars()*cs->mbmaxlen;
unknown's avatar
unknown committed
544
    set_name(str, length, cs);
unknown's avatar
unknown committed
545 546
    decimals=NOT_FIXED_DEC;
  }
547
  Item_string(const char *name_par, const char *str, uint length,
548
	      CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE)
unknown's avatar
unknown committed
549
  {
550
    collation.set(cs, dv);
551
    str_value.set(str,length,cs);
552
    max_length= str_value.numchars()*cs->mbmaxlen;
unknown's avatar
unknown committed
553
    set_name(name_par,0,cs);
unknown's avatar
unknown committed
554 555 556 557
    decimals=NOT_FIXED_DEC;
  }
  ~Item_string() {}
  enum Type type() const { return STRING_ITEM; }
558 559
  double val()
  { 
560
    int err;
561
    return my_strntod(str_value.charset(), (char*) str_value.ptr(),
562
		      str_value.length(), (char**) 0, &err);
563 564 565
  }
  longlong val_int()
  {
566
    int err;
567
    return my_strntoll(str_value.charset(), str_value.ptr(),
568
		       str_value.length(), 10, (char**) 0, &err);
569
  }
unknown's avatar
unknown committed
570
  String *val_str(String*) { return (String*) &str_value; }
unknown's avatar
unknown committed
571
  int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
572
  enum Item_result result_type () const { return STRING_RESULT; }
573
  enum_field_types field_type() const { return MYSQL_TYPE_STRING; }
unknown's avatar
unknown committed
574
  bool basic_const_item() const { return 1; }
575
  bool eq(const Item *item, bool binary_cmp) const;
576 577
  Item *new_item() 
  {
unknown's avatar
unknown committed
578
    return new Item_string(name, str_value.ptr(), max_length, &my_charset_bin);
579
  }
unknown's avatar
unknown committed
580
  String *const_string() { return &str_value; }
581
  inline void append(char *str, uint length) { str_value.append(str, length); }
unknown's avatar
unknown committed
582 583 584 585 586 587 588 589
  void print(String *str);
};

/* for show tables */

class Item_datetime :public Item_string
{
public:
unknown's avatar
unknown committed
590 591
  Item_datetime(const char *item_name): Item_string(item_name,"",0,
  						    &my_charset_bin)
unknown's avatar
unknown committed
592
  { max_length=19;}
593
  enum_field_types field_type() const { return MYSQL_TYPE_DATETIME; }
unknown's avatar
unknown committed
594 595 596 597 598
};

class Item_empty_string :public Item_string
{
public:
unknown's avatar
unknown committed
599 600
  Item_empty_string(const char *header,uint length) :Item_string("",0,
  							&my_charset_bin)
unknown's avatar
unknown committed
601
    { name=(char*) header; max_length=length;}
602
  void make_field(Send_field *field);
unknown's avatar
unknown committed
603 604
};

605 606 607 608 609 610 611 612 613 614 615 616 617 618
class Item_return_int :public Item_int
{
  enum_field_types int_field_type;
public:
  Item_return_int(const char *name, uint length,
		  enum_field_types field_type_arg)
    :Item_int(name, 0, length), int_field_type(field_type_arg)
  {
    unsigned_flag=1;
  }
  enum_field_types field_type() const { return int_field_type; }
};


unknown's avatar
unknown committed
619 620 621
class Item_varbinary :public Item
{
public:
622
  Item_varbinary(const char *str,uint str_length);
unknown's avatar
unknown committed
623 624 625 626 627
  ~Item_varbinary() {}
  enum Type type() const { return VARBIN_ITEM; }
  double val() { return (double) Item_varbinary::val_int(); }
  longlong val_int();
  String *val_str(String*) { return &str_value; }
unknown's avatar
unknown committed
628
  int save_in_field(Field *field, bool no_conversions);
629
  enum Item_result result_type () const { return STRING_RESULT; }
630
  enum_field_types field_type() const { return MYSQL_TYPE_STRING; }
unknown's avatar
unknown committed
631 632 633 634 635 636 637 638
};


class Item_result_field :public Item	/* Item with result field */
{
public:
  Field *result_field;				/* Save result here */
  Item_result_field() :result_field(0) {}
639
  // Constructor used for Item_sum/Item_cond_and/or (see Item comment)
640 641 642
  Item_result_field(THD *thd, Item_result_field &item):
    Item(thd, item), result_field(item.result_field)
  {}
unknown's avatar
unknown committed
643
  ~Item_result_field() {}			/* Required with gcc 2.95 */
644
  Field *get_tmp_table_field() { return result_field; }
645
  Field *tmp_table_field(TABLE *t_arg) { return result_field; }
unknown's avatar
unknown committed
646
  table_map used_tables() const { return 1; }
unknown's avatar
unknown committed
647
  virtual void fix_length_and_dec()=0;
unknown's avatar
unknown committed
648 649 650 651 652 653
  void set_result_field(Field *field) { result_field= field; }
  bool is_result_field() { return 1; }
  void save_in_result_field(bool no_conversions)
  {
    save_in_field(result_field, no_conversions);
  }
unknown's avatar
unknown committed
654 655 656 657 658 659
};


class Item_ref :public Item_ident
{
public:
unknown's avatar
unknown committed
660
  Field *result_field;				/* Save result here */
unknown's avatar
unknown committed
661
  Item **ref;
unknown's avatar
unknown committed
662 663
  Item_ref(const char *db_par, const char *table_name_par,
	   const char *field_name_par)
unknown's avatar
unknown committed
664
    :Item_ident(db_par,table_name_par,field_name_par),ref(0) {}
unknown's avatar
unknown committed
665
  Item_ref(Item **item, const char *table_name_par, const char *field_name_par)
unknown's avatar
unknown committed
666
    :Item_ident(NullS,table_name_par,field_name_par),ref(item) {}
667 668 669
  // Constructor need to process subselect with temporary tables (see Item)
  Item_ref(THD *thd, Item_ref &item)
    :Item_ident(thd, item), ref(item.ref) {}
unknown's avatar
unknown committed
670
  enum Type type() const		{ return REF_ITEM; }
671
  bool eq(const Item *item, bool binary_cmp) const
unknown's avatar
unknown committed
672
  { return ref && (*ref)->eq(item, binary_cmp); }
673
  ~Item_ref() { if (ref && (*ref) && (*ref) != this) delete *ref; }
unknown's avatar
unknown committed
674 675 676
  double val()
  {
    double tmp=(*ref)->val_result();
unknown's avatar
unknown committed
677
    null_value=(*ref)->null_value;
unknown's avatar
unknown committed
678 679 680 681 682
    return tmp;
  }
  longlong val_int()
  {
    longlong tmp=(*ref)->val_int_result();
unknown's avatar
unknown committed
683
    null_value=(*ref)->null_value;
unknown's avatar
unknown committed
684 685 686 687 688
    return tmp;
  }
  String *val_str(String* tmp)
  {
    tmp=(*ref)->str_result(tmp);
unknown's avatar
unknown committed
689
    null_value=(*ref)->null_value;
unknown's avatar
unknown committed
690 691
    return tmp;
  }
692 693 694
  bool is_null()
  {
    (void) (*ref)->val_int_result();
unknown's avatar
unknown committed
695
    return (*ref)->null_value;
696
  }
697
  bool get_date(TIME *ltime,uint fuzzydate)
698 699
  {
    return (null_value=(*ref)->get_date_result(ltime,fuzzydate));
unknown's avatar
unknown committed
700
  }
701
  bool send(Protocol *prot, String *tmp){ return (*ref)->send(prot, tmp); }
unknown's avatar
unknown committed
702
  void make_field(Send_field *field)	{ (*ref)->make_field(field); }
unknown's avatar
unknown committed
703
  bool fix_fields(THD *, struct st_table_list *, Item **);
unknown's avatar
unknown committed
704
  int save_in_field(Field *field, bool no_conversions)
705
  { return (*ref)->save_in_field(field, no_conversions); }
unknown's avatar
unknown committed
706 707
  void save_org_in_field(Field *field)	{ (*ref)->save_org_in_field(field); }
  enum Item_result result_type () const { return (*ref)->result_type(); }
708
  enum_field_types field_type() const   { return (*ref)->field_type(); }
unknown's avatar
unknown committed
709
  table_map used_tables() const		{ return (*ref)->used_tables(); }
710
  void set_result_field(Field *field)	{ result_field= field; }
unknown's avatar
unknown committed
711 712 713 714 715
  bool is_result_field() { return 1; }
  void save_in_result_field(bool no_conversions)
  {
    (*ref)->save_in_field(result_field, no_conversions);
  }
unknown's avatar
unknown committed
716
  Item *real_item() { return *ref; }
unknown's avatar
unknown committed
717
  void print(String *str);
unknown's avatar
unknown committed
718 719
};

720 721 722 723 724 725 726
class Item_in_subselect;
class Item_ref_null_helper: public Item_ref
{
protected:
  Item_in_subselect* owner;
public:
  Item_ref_null_helper(Item_in_subselect* master, Item **item,
unknown's avatar
unknown committed
727
		       const char *table_name_par, const char *field_name_par):
728 729 730 731
    Item_ref(item, table_name_par, field_name_par), owner(master) {}
  double val();
  longlong val_int();
  String* val_str(String* s);
732
  bool get_date(TIME *ltime, uint fuzzydate);
unknown's avatar
unknown committed
733
  void print(String *str);
734 735
};

736 737 738 739 740 741 742 743 744
class Item_null_helper :public Item_ref_null_helper
{
  Item *store;
public:
  Item_null_helper(Item_in_subselect* master, Item *item,
		   const char *table_name_par, const char *field_name_par)
    :Item_ref_null_helper(master, &store, table_name_par, field_name_par),
     store(item)
    {}
unknown's avatar
unknown committed
745
  void print(String *str);
746
};
unknown's avatar
unknown committed
747

748 749 750 751 752 753 754 755 756 757 758 759
/*
  The following class is used to optimize comparing of date columns
  We need to save the original item, to be able to set the field to the
  original value in 'opt_range'.
*/

class Item_int_with_ref :public Item_int
{
  Item *ref;
public:
  Item_int_with_ref(longlong i, Item *ref_arg) :Item_int(i), ref(ref_arg)
  {}
unknown's avatar
unknown committed
760
  int save_in_field(Field *field, bool no_conversions)
761
  {
762
    return ref->save_in_field(field, no_conversions);
763 764 765 766
  }
};


767
#include "gstream.h"
unknown's avatar
unknown committed
768
#include "spatial.h"
unknown's avatar
unknown committed
769 770
#include "item_sum.h"
#include "item_func.h"
771
#include "item_row.h"
unknown's avatar
unknown committed
772 773
#include "item_cmpfunc.h"
#include "item_strfunc.h"
774
#include "item_geofunc.h"
unknown's avatar
unknown committed
775 776
#include "item_timefunc.h"
#include "item_uniq.h"
777
#include "item_subselect.h"
unknown's avatar
unknown committed
778 779 780

class Item_copy_string :public Item
{
781
  enum enum_field_types cached_field_type;
unknown's avatar
unknown committed
782 783 784 785 786 787 788 789
public:
  Item *item;
  Item_copy_string(Item *i) :item(i)
  {
    null_value=maybe_null=item->maybe_null;
    decimals=item->decimals;
    max_length=item->max_length;
    name=item->name;
790
    cached_field_type= item->field_type();
unknown's avatar
unknown committed
791 792 793 794
  }
  ~Item_copy_string() { delete item; }
  enum Type type() const { return COPY_STR_ITEM; }
  enum Item_result result_type () const { return STRING_RESULT; }
795
  enum_field_types field_type() const { return cached_field_type; }
unknown's avatar
unknown committed
796
  double val()
797
  {
798
    int err;
799 800
    return (null_value ? 0.0 :
	    my_strntod(str_value.charset(), (char*) str_value.ptr(),
801
		       str_value.length(),NULL,&err));
802
  }
unknown's avatar
unknown committed
803
  longlong val_int()
804 805 806 807
  { 
    int err;
    return null_value ? LL(0) : my_strntoll(str_value.charset(),str_value.ptr(),str_value.length(),10, (char**) 0,&err); 
  }
unknown's avatar
unknown committed
808 809 810 811 812
  String *val_str(String*);
  void make_field(Send_field *field) { item->make_field(field); }
  void copy();
  table_map used_tables() const { return (table_map) 1L; }
  bool const_item() const { return 0; }
unknown's avatar
unknown committed
813
  bool is_null() { return null_value; }
unknown's avatar
unknown committed
814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870
};


class Item_buff :public Sql_alloc
{
public:
  my_bool null_value;
  Item_buff() :null_value(0) {}
  virtual bool cmp(void)=0;
  virtual ~Item_buff(); /*line -e1509 */
};

class Item_str_buff :public Item_buff
{
  Item *item;
  String value,tmp_value;
public:
  Item_str_buff(Item *arg) :item(arg),value(arg->max_length) {}
  bool cmp(void);
  ~Item_str_buff();				// Deallocate String:s
};


class Item_real_buff :public Item_buff
{
  Item *item;
  double value;
public:
  Item_real_buff(Item *item_par) :item(item_par),value(0.0) {}
  bool cmp(void);
};

class Item_int_buff :public Item_buff
{
  Item *item;
  longlong value;
public:
  Item_int_buff(Item *item_par) :item(item_par),value(0) {}
  bool cmp(void);
};


class Item_field_buff :public Item_buff
{
  char *buff;
  Field *field;
  uint length;

public:
  Item_field_buff(Item_field *item)
  {
    field=item->field;
    buff= (char*) sql_calloc(length=field->pack_length());
  }
  bool cmp(void);
};

unknown's avatar
SCRUM  
unknown committed
871 872 873 874
class Item_default_value : public Item_field
{
public:
  Item *arg;
unknown's avatar
SCRUM  
unknown committed
875 876
  Item_default_value() :
    Item_field((const char *)NULL, (const char *)NULL, (const char *)NULL), arg(NULL) {}
unknown's avatar
unknown committed
877
  Item_default_value(Item *a) :
unknown's avatar
SCRUM  
unknown committed
878
    Item_field((const char *)NULL, (const char *)NULL, (const char *)NULL), arg(a) {}
unknown's avatar
SCRUM  
unknown committed
879
  enum Type type() const { return DEFAULT_VALUE_ITEM; }
unknown's avatar
SCRUM  
unknown committed
880 881
  bool eq(const Item *item, bool binary_cmp) const;
  bool fix_fields(THD *, struct st_table_list *, Item **);
unknown's avatar
SCRUM  
unknown committed
882
  void print(String *str);
unknown's avatar
SCRUM  
unknown committed
883 884 885 886 887 888 889 890 891 892
  virtual bool basic_const_item() const { return true; }
  int save_in_field(Field *field, bool no_conversions)
  {
    if (!arg)
    {
      field->set_default();
      return 0;
    }
    return Item_field::save_in_field(field, no_conversions);
  }
unknown's avatar
SCRUM  
unknown committed
893
  table_map used_tables() const { return (table_map)0L; }
unknown's avatar
unknown committed
894 895 896 897 898 899
  
  bool walk(Item_processor processor, byte *args)
  {
    return arg->walk(processor, args) ||
      (this->*processor)(args);
  }
unknown's avatar
unknown committed
900
};
unknown's avatar
unknown committed
901

unknown's avatar
unknown committed
902 903 904 905 906 907 908 909 910 911 912 913 914 915 916
class Item_insert_value : public Item_field
{
public:
  Item *arg;
  Item_insert_value(Item *a) :
    Item_field((const char *)NULL, (const char *)NULL, (const char *)NULL), arg(a) {}
  bool eq(const Item *item, bool binary_cmp) const;
  bool fix_fields(THD *, struct st_table_list *, Item **);
  void print(String *str);
  virtual bool basic_const_item() const { return true; }
  int save_in_field(Field *field, bool no_conversions)
  {
    return Item_field::save_in_field(field, no_conversions);
  }
  table_map used_tables() const { return (table_map)0L; }
unknown's avatar
unknown committed
917 918 919 920 921 922

  bool walk(Item_processor processor, byte *args)
  {
    return arg->walk(processor, args) ||
	    (this->*processor)(args);
  }
unknown's avatar
unknown committed
923 924
};

925 926
class Item_cache: public Item
{
unknown's avatar
unknown committed
927 928
protected:
  Item *example;
929
  table_map used_table_map;
930
public:
unknown's avatar
unknown committed
931
  Item_cache(): example(0), used_table_map(0) {fixed= 1; null_value= 1;}
932 933 934

  void set_used_tables(table_map map) { used_table_map= map; }

unknown's avatar
unknown committed
935
  virtual bool allocate(uint i) { return 0; };
unknown's avatar
unknown committed
936
  virtual bool setup(Item *item) { example= item;  return 0; };
937 938 939 940 941 942 943
  virtual void store(Item *)= 0;
  void set_len_n_dec(uint32 max_len, uint8 dec)
  {
    max_length= max_len;
    decimals= dec;
  }
  enum Type type() const { return CACHE_ITEM; }
944
  static Item_cache* get_cache(Item_result type);
945
  table_map used_tables() const { return used_table_map; }
unknown's avatar
unknown committed
946
  void print(String *str);
947 948 949 950 951 952
};

class Item_cache_int: public Item_cache
{
  longlong value;
public:
953
  Item_cache_int(): Item_cache() {}
954
  
unknown's avatar
unknown committed
955
  void store(Item *item);
956 957
  double val() { return (double) value; }
  longlong val_int() { return value; }
958
  String* val_str(String *str) { str->set(value, default_charset()); return str; }
959 960 961 962 963 964 965
  enum Item_result result_type() const { return INT_RESULT; }
};

class Item_cache_real: public Item_cache
{
  double value;
public:
966
  Item_cache_real(): Item_cache() {}
967
  
unknown's avatar
unknown committed
968
  void store(Item *item);
969 970 971 972
  double val() { return value; }
  longlong val_int() { return (longlong) (value+(value > 0 ? 0.5 : -0.5)); }
  String* val_str(String *str)
  {
973
    str->set(value, decimals, default_charset());
974 975 976 977 978 979 980 981
    return str;
  }
  enum Item_result result_type() const { return REAL_RESULT; }
};

class Item_cache_str: public Item_cache
{
  char buffer[80];
982
  String *value, value_buff;
983
public:
984
  Item_cache_str(): Item_cache() { }
985
  
986 987 988
  void store(Item *item);
  double val();
  longlong val_int();
989 990 991 992 993
  String* val_str(String *) { return value; }
  enum Item_result result_type() const { return STRING_RESULT; }
  CHARSET_INFO *charset() const { return value->charset(); };
};

unknown's avatar
unknown committed
994 995 996
class Item_cache_row: public Item_cache
{
  Item_cache  **values;
unknown's avatar
unknown committed
997
  uint item_count;
unknown's avatar
unknown committed
998
public:
999
  Item_cache_row(): Item_cache(), values(0), item_count(2) {}
unknown's avatar
unknown committed
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
  
  /*
    'allocate' used only in row transformer, to preallocate space for row 
    cache.
  */
  bool allocate(uint num);
  /*
    'setup' is needed only by row => it not called by simple row subselect
    (only by IN subselect (in subselect optimizer))
  */
  bool setup(Item *item);
  void store(Item *item);
  void illegal_method_call(const char *);
  void make_field(Send_field *)
  {
    illegal_method_call((const char*)"make_field");
  };
  double val()
  {
    illegal_method_call((const char*)"val");
    return 0;
  };
  longlong val_int()
  {
    illegal_method_call((const char*)"val_int");
    return 0;
  };
  String *val_str(String *)
  {
    illegal_method_call((const char*)"val_str");
    return 0;
  };
  enum Item_result result_type() const { return ROW_RESULT; }
  
unknown's avatar
unknown committed
1034
  uint cols() { return item_count; }
unknown's avatar
unknown committed
1035 1036 1037 1038 1039 1040 1041
  Item* el(uint i) { return values[i]; }
  Item** addr(uint i) { return (Item **) (values + i); }
  bool check_cols(uint c);
  bool null_inside();
  void bring_value();
};

unknown's avatar
unknown committed
1042 1043 1044 1045
extern Item_buff *new_Item_buff(Item *item);
extern Item_result item_cmp_type(Item_result a,Item_result b);
extern Item *resolve_const_item(Item *item,Item *cmp_item);
extern bool field_is_equal_to_item(Field *field,Item *item);