item.h 28.7 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000-2003
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 109 110 111
  String str_value;			/* used to store value */
  my_string name;			/* Name from select */
  Item *next;
  uint32 max_length;
  uint8 marker,decimals;
  my_bool maybe_null;			/* If item may be null */
  my_bool null_value;			/* if item is null */
112
  my_bool unsigned_flag;
unknown's avatar
unknown committed
113
  my_bool with_sum_func;
114
  my_bool fixed;                        /* If item fixed with fix_fields */
115 116
  DTCollation collation;
  
unknown's avatar
unknown committed
117 118
  // alloc & destruct is done as start of select using sql_alloc
  Item();
119 120 121 122 123 124
  /*
     Constructor used by Item_field, Item_ref & agregate (sum) functions.
     Used for duplicating lists in processing queries with temporary
     tables
  */
  Item(THD *thd, Item &item);
unknown's avatar
unknown committed
125
  virtual ~Item() { name=0; }		/*lint -e1509 */
unknown's avatar
unknown committed
126
  void set_name(const char *str,uint length, CHARSET_INFO *cs);
unknown's avatar
unknown committed
127
  void init_make_field(Send_field *tmp_field,enum enum_field_types type);
128
  virtual void make_field(Send_field *field);
unknown's avatar
unknown committed
129
  virtual bool fix_fields(THD *, struct st_table_list *, Item **);
unknown's avatar
unknown committed
130
  virtual int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
131
  virtual void save_org_in_field(Field *field)
132
  { (void) save_in_field(field, 1); }
unknown's avatar
unknown committed
133
  virtual int save_safe_in_field(Field *field)
134
  { return save_in_field(field, 1); }
135
  virtual bool send(Protocol *protocol, String *str);
136
  virtual bool eq(const Item *, bool binary_cmp) const;
unknown's avatar
unknown committed
137
  virtual Item_result result_type () const { return REAL_RESULT; }
138
  virtual enum_field_types field_type() const;
unknown's avatar
unknown committed
139 140 141 142
  virtual enum Type type() const =0;
  virtual double val()=0;
  virtual longlong val_int()=0;
  virtual String *val_str(String*)=0;
143 144
  virtual Field *tmp_table_field() { return 0; }
  virtual Field *tmp_table_field(TABLE *t_arg) { return 0; }
unknown's avatar
unknown committed
145 146 147 148
  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); }
149
  /* bit map of tables used by item */
unknown's avatar
unknown committed
150
  virtual table_map used_tables() const { return (table_map) 0L; }
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
  /*
    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
167 168 169 170 171 172 173 174
  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()); }
  virtual void update_used_tables() {}
175
  virtual void split_sum_func(Item **ref_pointer_array, List<Item> &fields) {}
unknown's avatar
unknown committed
176 177
  virtual bool get_date(TIME *ltime,bool fuzzydate);
  virtual bool get_time(TIME *ltime);
178 179
  virtual bool get_date_result(TIME *ltime,bool fuzzydate)
  { return get_date(ltime,fuzzydate); }
180
  virtual bool is_null() { return 0; }
181
  virtual void top_level_item() {}
unknown's avatar
unknown committed
182 183 184
  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
185
  virtual void no_rows_in_result() {}
186
  virtual Item *copy_or_same(THD *thd) { return this; }
unknown's avatar
unknown committed
187
  virtual Item *real_item() { return this; }
188
  virtual Item *get_tmp_table_item(THD *thd) { return copy_or_same(thd); }
unknown's avatar
unknown committed
189

190
  CHARSET_INFO *default_charset() const;
unknown's avatar
unknown committed
191 192 193 194 195 196 197

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

  virtual bool remove_dependence_processor(byte * arg) { return 0; }
198
  
unknown's avatar
unknown committed
199 200 201
  // Row emulation
  virtual uint cols() { return 1; }
  virtual Item* el(uint i) { return this; }
202
  virtual Item** addr(uint i) { return 0; }
unknown's avatar
unknown committed
203
  virtual bool check_cols(uint c);
unknown's avatar
unknown committed
204
  // It is not row => null inside is impossible
205 206 207
  virtual bool null_inside() { return 0; }
  // used in row subselects to get value of elements
  virtual void bring_value() {}
unknown's avatar
unknown committed
208 209 210
};


unknown's avatar
unknown committed
211
class st_select_lex;
unknown's avatar
unknown committed
212 213 214 215 216 217
class Item_ident :public Item
{
public:
  const char *db_name;
  const char *table_name;
  const char *field_name;
unknown's avatar
unknown committed
218
  st_select_lex *depended_from;
unknown's avatar
unknown committed
219 220
  Item_ident(const char *db_name_par,const char *table_name_par,
	     const char *field_name_par)
221
    :db_name(db_name_par), table_name(table_name_par),
unknown's avatar
unknown committed
222
     field_name(field_name_par), depended_from(0)
unknown's avatar
unknown committed
223
    { name = (char*) field_name_par; }
224 225
  // Constructor used by Item_field & Item_ref (see Item comment)
  Item_ident(THD *thd, Item_ident &item);
unknown's avatar
unknown committed
226
  const char *full_name() const;
unknown's avatar
unknown committed
227 228

  bool remove_dependence_processor(byte * arg);
unknown's avatar
unknown committed
229 230
};

unknown's avatar
unknown committed
231

unknown's avatar
unknown committed
232 233 234 235 236 237 238 239 240 241
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)
242
  { collation.set(DERIVATION_IMPLICIT); }
243 244
  // Constructor need to process subselect with temporary tables (see Item)
  Item_field(THD *thd, Item_field &item);
unknown's avatar
unknown committed
245 246
  Item_field(Field *field);
  enum Type type() const { return FIELD_ITEM; }
247
  bool eq(const Item *item, bool binary_cmp) const;
unknown's avatar
unknown committed
248 249 250 251 252 253
  double val();
  longlong val_int();
  String *val_str(String*);
  double val_result();
  longlong val_int_result();
  String *str_result(String* tmp);
254
  bool send(Protocol *protocol, String *str_arg);
unknown's avatar
unknown committed
255
  bool fix_fields(THD *, struct st_table_list *, Item **);
256
  void make_field(Send_field *tmp_field);
unknown's avatar
unknown committed
257
  int save_in_field(Field *field,bool no_conversions);
unknown's avatar
unknown committed
258 259 260 261 262 263
  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
264
  enum_field_types field_type() const
265 266 267
  {
    return field->type();
  }
268 269
  Field *tmp_table_field() { return result_field; }
  Field *tmp_table_field(TABLE *t_arg) { return result_field; }
270 271 272
  bool get_date(TIME *ltime,bool fuzzydate);
  bool get_date_result(TIME *ltime,bool fuzzydate);
  bool get_time(TIME *ltime);
unknown's avatar
unknown committed
273
  bool is_null() { return field->is_null(); }
274
  Item *get_tmp_table_item(THD *thd);
unknown's avatar
SCRUM  
unknown committed
275
  friend class Item_default_value;
unknown's avatar
unknown committed
276
  friend class Item_insert_value;
unknown's avatar
unknown committed
277 278 279 280 281 282 283 284
};

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; }
285
  bool eq(const Item *item, bool binary_cmp) const;
unknown's avatar
unknown committed
286 287 288
  double val();
  longlong val_int();
  String *val_str(String *str);
unknown's avatar
unknown committed
289
  int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
290
  int save_safe_in_field(Field *field);
unknown's avatar
unknown committed
291
  bool send(Protocol *protocol, String *str);
292 293 294 295 296 297 298 299
  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
300 301
  bool basic_const_item() const { return 1; }
  Item *new_item() { return new Item_null(name); }
unknown's avatar
unknown committed
302
  bool is_null() { return 1; }
unknown's avatar
unknown committed
303 304
};

unknown's avatar
unknown committed
305 306 307 308 309
class Item_param :public Item
{
public:    
  longlong int_value;
  double   real_value;
310
  TIME     ltime;
unknown's avatar
unknown committed
311 312 313
  enum Item_result item_result_type;
  enum Type item_type;
  enum enum_field_types buffer_type;
314
  bool item_is_time;
315 316
  bool long_data_supplied;
  uint pos_in_query;
unknown's avatar
unknown committed
317

318
  Item_param::Item_param(uint position)
319
  { 
320 321
    name= (char*) "?";
    pos_in_query= position;
unknown's avatar
unknown committed
322
    item_type= STRING_ITEM;
323
    item_result_type = STRING_RESULT;
324
    item_is_time= false;
325
    long_data_supplied= false;
unknown's avatar
unknown committed
326 327 328 329 330
  }
  enum Type type() const { return item_type; }
  double val();
  longlong val_int();
  String *val_str(String*);
unknown's avatar
unknown committed
331
  int  save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
332 333 334
  void set_null();
  void set_int(longlong i);
  void set_double(double i);
unknown's avatar
unknown committed
335 336 337 338
  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
339
  void set_long_end();
340 341
  void set_time(TIME *tm, timestamp_type type);
  bool get_time(TIME *tm);
342
  void reset() {}
unknown's avatar
unknown committed
343
  void (*setup_param_func)(Item_param *param, uchar **pos);
unknown's avatar
unknown committed
344
  enum Item_result result_type () const
unknown's avatar
unknown committed
345
  { return item_result_type; }
346
  String *query_val_str(String *str);
347
  enum_field_types field_type() const { return MYSQL_TYPE_STRING; }
348
  Item *new_item() { return new Item_param(pos_in_query); }
unknown's avatar
unknown committed
349
};
unknown's avatar
unknown committed
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365

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
366
    { max_length= (uint) strlen(str_arg); name=(char*) str_arg;}
unknown's avatar
unknown committed
367
  enum Type type() const { return INT_ITEM; }
368 369
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types field_type() const { return MYSQL_TYPE_LONGLONG; }
unknown's avatar
unknown committed
370 371 372
  longlong val_int() { return value; }
  double val() { return (double) value; }
  String *val_str(String*);
unknown's avatar
unknown committed
373
  int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
374 375 376 377 378 379
  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
380 381 382 383 384
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
385
  Item_uint(uint32 i) :Item_int((longlong) i, 10) {}
386
  double val() { return ulonglong2double((ulonglong)value); }
unknown's avatar
unknown committed
387 388
  String *val_str(String*);
  Item *new_item() { return new Item_uint(name,max_length); }
389 390 391 392 393 394
  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
395 396 397 398
  void print(String *str);
};


unknown's avatar
unknown committed
399 400 401 402 403 404 405 406
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
407
    decimals=(uint8) nr_of_decimals(str_arg);
unknown's avatar
unknown committed
408 409 410 411 412 413
    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
414
    decimals=(uint8) decimal_par;
unknown's avatar
unknown committed
415 416 417
    max_length=length;
  }
  Item_real(double value_par) :value(value_par) {}
unknown's avatar
unknown committed
418
  int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
419
  enum Type type() const { return REAL_ITEM; }
420
  enum_field_types field_type() const { return MYSQL_TYPE_DOUBLE; }
unknown's avatar
unknown committed
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
  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
442
  Item_string(const char *str,uint length,
443
  	      CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE)
unknown's avatar
unknown committed
444
  {
445
    collation.set(cs, dv);
446
    str_value.set(str,length,cs);
447
    max_length= str_value.numchars()*cs->mbmaxlen;
unknown's avatar
unknown committed
448
    set_name(str, length, cs);
unknown's avatar
unknown committed
449 450
    decimals=NOT_FIXED_DEC;
  }
451
  Item_string(const char *name_par, const char *str, uint length,
452
	      CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE)
unknown's avatar
unknown committed
453
  {
454
    collation.set(cs, dv);
455
    str_value.set(str,length,cs);
456
    max_length= str_value.numchars()*cs->mbmaxlen;
unknown's avatar
unknown committed
457
    set_name(name_par,0,cs);
unknown's avatar
unknown committed
458 459 460 461
    decimals=NOT_FIXED_DEC;
  }
  ~Item_string() {}
  enum Type type() const { return STRING_ITEM; }
462 463
  double val()
  { 
464
    int err;
465
    return my_strntod(str_value.charset(), (char*) str_value.ptr(),
466
		      str_value.length(), (char**) 0, &err);
467 468 469
  }
  longlong val_int()
  {
470
    int err;
471
    return my_strntoll(str_value.charset(), str_value.ptr(),
472
		       str_value.length(), 10, (char**) 0, &err);
473
  }
unknown's avatar
unknown committed
474
  String *val_str(String*) { return (String*) &str_value; }
unknown's avatar
unknown committed
475
  int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
476
  enum Item_result result_type () const { return STRING_RESULT; }
477
  enum_field_types field_type() const { return MYSQL_TYPE_STRING; }
unknown's avatar
unknown committed
478
  bool basic_const_item() const { return 1; }
479
  bool eq(const Item *item, bool binary_cmp) const;
480 481
  Item *new_item() 
  {
unknown's avatar
unknown committed
482
    return new Item_string(name, str_value.ptr(), max_length, &my_charset_bin);
483
  }
unknown's avatar
unknown committed
484
  String *const_string() { return &str_value; }
485
  inline void append(char *str, uint length) { str_value.append(str, length); }
unknown's avatar
unknown committed
486 487 488 489 490 491 492 493
  void print(String *str);
};

/* for show tables */

class Item_datetime :public Item_string
{
public:
unknown's avatar
unknown committed
494 495
  Item_datetime(const char *item_name): Item_string(item_name,"",0,
  						    &my_charset_bin)
unknown's avatar
unknown committed
496
  { max_length=19;}
497
  enum_field_types field_type() const { return MYSQL_TYPE_DATETIME; }
unknown's avatar
unknown committed
498 499 500 501 502
};

class Item_empty_string :public Item_string
{
public:
unknown's avatar
unknown committed
503 504
  Item_empty_string(const char *header,uint length) :Item_string("",0,
  							&my_charset_bin)
unknown's avatar
unknown committed
505 506 507
    { name=(char*) header; max_length=length;}
};

508 509 510 511 512 513 514 515 516 517 518 519 520 521
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
522 523 524
class Item_varbinary :public Item
{
public:
525
  Item_varbinary(const char *str,uint str_length);
unknown's avatar
unknown committed
526 527 528 529 530
  ~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
531
  int save_in_field(Field *field, bool no_conversions);
532
  enum Item_result result_type () const { return STRING_RESULT; }
533
  enum_field_types field_type() const { return MYSQL_TYPE_STRING; }
unknown's avatar
unknown committed
534 535 536 537 538 539 540 541
};


class Item_result_field :public Item	/* Item with result field */
{
public:
  Field *result_field;				/* Save result here */
  Item_result_field() :result_field(0) {}
542 543 544 545
  // Constructor used for Item_sum (see Item comment)
  Item_result_field(THD *thd, Item_result_field &item):
    Item(thd, item), result_field(item.result_field)
  {}
unknown's avatar
unknown committed
546
  ~Item_result_field() {}			/* Required with gcc 2.95 */
547 548
  Field *tmp_table_field() { return result_field; }
  Field *tmp_table_field(TABLE *t_arg) { return result_field; }
unknown's avatar
unknown committed
549
  table_map used_tables() const { return 1; }
unknown's avatar
unknown committed
550
  virtual void fix_length_and_dec()=0;
unknown's avatar
unknown committed
551 552 553 554 555 556
  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
557 558 559 560 561 562
};


class Item_ref :public Item_ident
{
public:
unknown's avatar
unknown committed
563
  Field *result_field;				/* Save result here */
unknown's avatar
unknown committed
564
  Item **ref;
unknown's avatar
unknown committed
565 566
  Item_ref(const char *db_par, const char *table_name_par,
	   const char *field_name_par)
unknown's avatar
unknown committed
567
    :Item_ident(db_par,table_name_par,field_name_par),ref(0) {}
unknown's avatar
unknown committed
568
  Item_ref(Item **item, const char *table_name_par, const char *field_name_par)
unknown's avatar
unknown committed
569
    :Item_ident(NullS,table_name_par,field_name_par),ref(item) {}
570 571 572
  // 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
573
  enum Type type() const		{ return REF_ITEM; }
574
  bool eq(const Item *item, bool binary_cmp) const
unknown's avatar
unknown committed
575
  { return ref && (*ref)->eq(item, binary_cmp); }
576
  ~Item_ref() { if (ref && (*ref) && (*ref) != this) delete *ref; }
unknown's avatar
unknown committed
577 578 579
  double val()
  {
    double tmp=(*ref)->val_result();
unknown's avatar
unknown committed
580
    null_value=(*ref)->null_value;
unknown's avatar
unknown committed
581 582 583 584 585
    return tmp;
  }
  longlong val_int()
  {
    longlong tmp=(*ref)->val_int_result();
unknown's avatar
unknown committed
586
    null_value=(*ref)->null_value;
unknown's avatar
unknown committed
587 588 589 590 591
    return tmp;
  }
  String *val_str(String* tmp)
  {
    tmp=(*ref)->str_result(tmp);
unknown's avatar
unknown committed
592
    null_value=(*ref)->null_value;
unknown's avatar
unknown committed
593 594
    return tmp;
  }
595 596 597
  bool is_null()
  {
    (void) (*ref)->val_int_result();
unknown's avatar
unknown committed
598
    return (*ref)->null_value;
599
  }
unknown's avatar
unknown committed
600
  bool get_date(TIME *ltime,bool fuzzydate)
601 602
  {
    return (null_value=(*ref)->get_date_result(ltime,fuzzydate));
unknown's avatar
unknown committed
603
  }
604
  bool send(Protocol *prot, String *tmp){ return (*ref)->send(prot, tmp); }
unknown's avatar
unknown committed
605
  void make_field(Send_field *field)	{ (*ref)->make_field(field); }
unknown's avatar
unknown committed
606
  bool fix_fields(THD *, struct st_table_list *, Item **);
unknown's avatar
unknown committed
607
  int save_in_field(Field *field, bool no_conversions)
608
  { return (*ref)->save_in_field(field, no_conversions); }
unknown's avatar
unknown committed
609 610
  void save_org_in_field(Field *field)	{ (*ref)->save_org_in_field(field); }
  enum Item_result result_type () const { return (*ref)->result_type(); }
611
  enum_field_types field_type() const   { return (*ref)->field_type(); }
unknown's avatar
unknown committed
612
  table_map used_tables() const		{ return (*ref)->used_tables(); }
613
  void set_result_field(Field *field)	{ result_field= field; }
unknown's avatar
unknown committed
614 615 616 617 618
  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
619
  Item *real_item() { return *ref; }
unknown's avatar
unknown committed
620 621
};

622 623 624 625 626 627 628
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
629
		       const char *table_name_par, const char *field_name_par):
630 631 632 633 634
    Item_ref(item, table_name_par, field_name_par), owner(master) {}
  double val();
  longlong val_int();
  String* val_str(String* s);
  bool get_date(TIME *ltime, bool fuzzydate);
635 636 637 638 639 640 641 642 643
  void print(String *str)
  {
    str->append("ref_null_helper(");
    if (ref && *ref)
      (*ref)->print(str);
    else
      str->append('?');
    str->append(')');
  }
644 645
};

646 647 648 649 650 651 652 653 654 655
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
656

657 658 659 660 661 662 663 664 665 666 667 668
/*
  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
669
  int save_in_field(Field *field, bool no_conversions)
670
  {
671
    return ref->save_in_field(field, no_conversions);
672 673 674 675
  }
};


676
#include "gstream.h"
unknown's avatar
unknown committed
677
#include "spatial.h"
unknown's avatar
unknown committed
678 679
#include "item_sum.h"
#include "item_func.h"
680
#include "item_row.h"
unknown's avatar
unknown committed
681 682
#include "item_cmpfunc.h"
#include "item_strfunc.h"
683
#include "item_geofunc.h"
unknown's avatar
unknown committed
684 685
#include "item_timefunc.h"
#include "item_uniq.h"
686
#include "item_subselect.h"
unknown's avatar
unknown committed
687 688 689

class Item_copy_string :public Item
{
690
  enum enum_field_types cached_field_type;
unknown's avatar
unknown committed
691 692 693 694 695 696 697 698
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;
699
    cached_field_type= item->field_type();
unknown's avatar
unknown committed
700 701 702 703
  }
  ~Item_copy_string() { delete item; }
  enum Type type() const { return COPY_STR_ITEM; }
  enum Item_result result_type () const { return STRING_RESULT; }
704
  enum_field_types field_type() const { return cached_field_type; }
unknown's avatar
unknown committed
705
  double val()
706
  {
707
    int err;
708 709
    return (null_value ? 0.0 :
	    my_strntod(str_value.charset(), (char*) str_value.ptr(),
710
		       str_value.length(),NULL,&err));
711
  }
unknown's avatar
unknown committed
712
  longlong val_int()
713 714 715 716
  { 
    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
717 718 719 720 721
  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
722
  bool is_null() { return null_value; }
unknown's avatar
unknown committed
723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779
};


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
780 781 782 783
class Item_default_value : public Item_field
{
public:
  Item *arg;
unknown's avatar
SCRUM  
unknown committed
784 785
  Item_default_value() :
    Item_field((const char *)NULL, (const char *)NULL, (const char *)NULL), arg(NULL) {}
unknown's avatar
unknown committed
786
  Item_default_value(Item *a) :
unknown's avatar
SCRUM  
unknown committed
787
    Item_field((const char *)NULL, (const char *)NULL, (const char *)NULL), arg(a) {}
unknown's avatar
SCRUM  
unknown committed
788
  enum Type type() const { return DEFAULT_VALUE_ITEM; }
unknown's avatar
SCRUM  
unknown committed
789 790
  bool eq(const Item *item, bool binary_cmp) const;
  bool fix_fields(THD *, struct st_table_list *, Item **);
unknown's avatar
SCRUM  
unknown committed
791
  void print(String *str);
unknown's avatar
SCRUM  
unknown committed
792 793 794 795 796 797 798 799 800 801
  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
802
  table_map used_tables() const { return (table_map)0L; }
unknown's avatar
unknown committed
803 804 805 806 807 808
  
  bool walk(Item_processor processor, byte *args)
  {
    return arg->walk(processor, args) ||
      (this->*processor)(args);
  }
unknown's avatar
unknown committed
809
};
unknown's avatar
unknown committed
810

unknown's avatar
unknown committed
811 812 813 814 815 816 817 818 819 820 821 822 823 824 825
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
826 827 828 829 830 831

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

834 835
class Item_cache: public Item
{
836
  table_map used_table_map;
837
public:
838 839 840 841
  Item_cache(): used_table_map(0) {fixed= 1; null_value= 1;}

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

unknown's avatar
unknown committed
842 843
  virtual bool allocate(uint i) { return 0; };
  virtual bool setup(Item *) { return 0; };
844 845 846 847 848 849 850
  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; }
851
  static Item_cache* get_cache(Item_result type);
852
  table_map used_tables() const { return used_table_map; }
853 854 855 856 857 858
};

class Item_cache_int: public Item_cache
{
  longlong value;
public:
859
  Item_cache_int(): Item_cache() {}
860 861 862 863 864 865 866 867
  
  void store(Item *item)
  {
    value= item->val_int_result();
    null_value= item->null_value;
  }
  double val() { return (double) value; }
  longlong val_int() { return value; }
868
  String* val_str(String *str) { str->set(value, default_charset()); return str; }
869 870 871 872 873 874 875
  enum Item_result result_type() const { return INT_RESULT; }
};

class Item_cache_real: public Item_cache
{
  double value;
public:
876
  Item_cache_real(): Item_cache() {}
877 878 879 880 881 882 883 884 885 886
  
  void store(Item *item)
  {
    value= item->val_result();
    null_value= item->null_value;
  }
  double val() { return value; }
  longlong val_int() { return (longlong) (value+(value > 0 ? 0.5 : -0.5)); }
  String* val_str(String *str)
  {
887
    str->set(value, decimals, default_charset());
888 889 890 891 892 893 894 895
    return str;
  }
  enum Item_result result_type() const { return REAL_RESULT; }
};

class Item_cache_str: public Item_cache
{
  char buffer[80];
896
  String *value, value_buff;
897
public:
898
  Item_cache_str(): Item_cache() { }
899
  
900 901 902
  void store(Item *item);
  double val();
  longlong val_int();
903 904 905 906 907
  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
908 909 910
class Item_cache_row: public Item_cache
{
  Item_cache  **values;
unknown's avatar
unknown committed
911
  uint item_count;
unknown's avatar
unknown committed
912
public:
913
  Item_cache_row(): Item_cache(), values(0), item_count(2) {}
unknown's avatar
unknown committed
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947
  
  /*
    '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
948
  uint cols() { return item_count; }
unknown's avatar
unknown committed
949 950 951 952 953 954 955
  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
956 957 958 959
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);