item.h 95.8 KB
Newer Older
1
/* Copyright (C) 2000-2006 MySQL AB
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2

bk@work.mysql.com's avatar
bk@work.mysql.com committed
3 4
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
5
   the Free Software Foundation; version 2 of the License.
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
6

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
12 13 14 15 16
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


17
#ifdef USE_PRAGMA_INTERFACE
bk@work.mysql.com's avatar
bk@work.mysql.com committed
18 19 20
#pragma interface			/* gcc class implementation */
#endif

21
class Protocol;
22
struct TABLE_LIST;
23
void item_init(void);			/* Init item functions */
24
class Item_field;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
25

26 27
/*
   "Declared Type Collation"
28
   A combination of collation and its derivation.
29

30
  Flags for collation aggregation modes:
bar@mysql.com's avatar
bar@mysql.com committed
31 32 33 34
  MY_COLL_ALLOW_SUPERSET_CONV  - allow conversion to a superset
  MY_COLL_ALLOW_COERCIBLE_CONV - allow conversion of a coercible value
                                 (i.e. constant).
  MY_COLL_ALLOW_CONV           - allow any kind of conversion
35
                                 (combination of the above two)
bar@mysql.com's avatar
bar@mysql.com committed
36 37 38 39
  MY_COLL_DISALLOW_NONE        - don't allow return DERIVATION_NONE
                                 (e.g. when aggregating for comparison)
  MY_COLL_CMP_CONV             - combination of MY_COLL_ALLOW_CONV
                                 and MY_COLL_DISALLOW_NONE
40 41 42 43
*/

#define MY_COLL_ALLOW_SUPERSET_CONV   1
#define MY_COLL_ALLOW_COERCIBLE_CONV  2
bar@mysql.com's avatar
bar@mysql.com committed
44 45 46
#define MY_COLL_ALLOW_CONV            3
#define MY_COLL_DISALLOW_NONE         4
#define MY_COLL_CMP_CONV              7
47

48 49 50 51
class DTCollation {
public:
  CHARSET_INFO     *collation;
  enum Derivation derivation;
52
  uint repertoire;
53
  
54 55 56 57 58
  void set_repertoire_from_charset(CHARSET_INFO *cs)
  {
    repertoire= cs->state & MY_CS_PUREASCII ?
                MY_REPERTOIRE_ASCII : MY_REPERTOIRE_UNICODE30;
  }
59 60 61 62
  DTCollation()
  {
    collation= &my_charset_bin;
    derivation= DERIVATION_NONE;
63
    repertoire= MY_REPERTOIRE_UNICODE30;
64 65 66 67 68
  }
  DTCollation(CHARSET_INFO *collation_arg, Derivation derivation_arg)
  {
    collation= collation_arg;
    derivation= derivation_arg;
69
    set_repertoire_from_charset(collation_arg);
70
  }
71
  void set(DTCollation &dt)
72
  { 
73 74
    collation= dt.collation;
    derivation= dt.derivation;
75
    repertoire= dt.repertoire;
76 77 78 79 80
  }
  void set(CHARSET_INFO *collation_arg, Derivation derivation_arg)
  {
    collation= collation_arg;
    derivation= derivation_arg;
81 82 83 84 85 86 87 88 89
    set_repertoire_from_charset(collation_arg);
  }
  void set(CHARSET_INFO *collation_arg,
           Derivation derivation_arg,
           uint repertoire_arg)
  {
    collation= collation_arg;
    derivation= derivation_arg;
    repertoire= repertoire_arg;
90 91
  }
  void set(CHARSET_INFO *collation_arg)
92 93 94 95
  {
    collation= collation_arg;
    set_repertoire_from_charset(collation_arg);
  }
96 97
  void set(Derivation derivation_arg)
  { derivation= derivation_arg; }
98 99 100
  bool aggregate(DTCollation &dt, uint flags= 0);
  bool set(DTCollation &dt1, DTCollation &dt2, uint flags= 0)
  { set(dt1); return aggregate(dt2, flags); }
101 102 103 104
  const char *derivation_name() const
  {
    switch(derivation)
    {
105
      case DERIVATION_IGNORABLE: return "IGNORABLE";
106 107
      case DERIVATION_COERCIBLE: return "COERCIBLE";
      case DERIVATION_IMPLICIT:  return "IMPLICIT";
108
      case DERIVATION_SYSCONST:  return "SYSCONST";
109 110 111 112 113 114 115
      case DERIVATION_EXPLICIT:  return "EXPLICIT";
      case DERIVATION_NONE:      return "NONE";
      default: return "UNKNOWN";
    }
  }
};

116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168
/*************************************************************************/
/*
  A framework to easily handle different return types for hybrid items
  (hybrid item is an item whose operand can be of any type, e.g. integer,
  real, decimal).
*/

struct Hybrid_type_traits;

struct Hybrid_type
{
  longlong integer;

  double real;
  /*
    Use two decimal buffers interchangeably to speed up += operation
    which has no native support in decimal library.
    Hybrid_type+= arg is implemented as dec_buf[1]= dec_buf[0] + arg.
    The third decimal is used as a handy temporary storage.
  */
  my_decimal dec_buf[3];
  int used_dec_buf_no;

  /*
    Traits moved to a separate class to
      a) be able to easily change object traits in runtime
      b) they work as a differentiator for the union above
  */
  const Hybrid_type_traits *traits;

  Hybrid_type() {}
  /* XXX: add traits->copy() when needed */
  Hybrid_type(const Hybrid_type &rhs) :traits(rhs.traits) {}
};


/* Hybryd_type_traits interface + default implementation for REAL_RESULT */

struct Hybrid_type_traits
{
  virtual Item_result type() const { return REAL_RESULT; }

  virtual void
  fix_length_and_dec(Item *item, Item *arg) const;

  /* Hybrid_type operations. */
  virtual void set_zero(Hybrid_type *val) const { val->real= 0.0; }
  virtual void add(Hybrid_type *val, Field *f) const
  { val->real+= f->val_real(); }
  virtual void div(Hybrid_type *val, ulonglong u) const
  { val->real/= ulonglong2double(u); }

  virtual longlong val_int(Hybrid_type *val, bool unsigned_flag) const
169
  { return (longlong) rint(val->real); }
170 171 172 173
  virtual double val_real(Hybrid_type *val) const { return val->real; }
  virtual my_decimal *val_decimal(Hybrid_type *val, my_decimal *buf) const;
  virtual String *val_str(Hybrid_type *val, String *buf, uint8 decimals) const;
  static const Hybrid_type_traits *instance();
174 175
  Hybrid_type_traits() {}
  virtual ~Hybrid_type_traits() {}
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
};


struct Hybrid_type_traits_decimal: public Hybrid_type_traits
{
  virtual Item_result type() const { return DECIMAL_RESULT; }

  virtual void
  fix_length_and_dec(Item *arg, Item *item) const;

  /* Hybrid_type operations. */
  virtual void set_zero(Hybrid_type *val) const;
  virtual void add(Hybrid_type *val, Field *f) const;
  virtual void div(Hybrid_type *val, ulonglong u) const;

  virtual longlong val_int(Hybrid_type *val, bool unsigned_flag) const;
  virtual double val_real(Hybrid_type *val) const;
  virtual my_decimal *val_decimal(Hybrid_type *val, my_decimal *buf) const
  { return &val->dec_buf[val->used_dec_buf_no]; }
  virtual String *val_str(Hybrid_type *val, String *buf, uint8 decimals) const;
  static const Hybrid_type_traits_decimal *instance();
197
  Hybrid_type_traits_decimal() {};
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
};


struct Hybrid_type_traits_integer: public Hybrid_type_traits
{
  virtual Item_result type() const { return INT_RESULT; }

  virtual void
  fix_length_and_dec(Item *arg, Item *item) const;

  /* Hybrid_type operations. */
  virtual void set_zero(Hybrid_type *val) const
  { val->integer= 0; }
  virtual void add(Hybrid_type *val, Field *f) const
  { val->integer+= f->val_int(); }
  virtual void div(Hybrid_type *val, ulonglong u) const
  { val->integer/= (longlong) u; }

  virtual longlong val_int(Hybrid_type *val, bool unsigned_flag) const
  { return val->integer; }
  virtual double val_real(Hybrid_type *val) const
  { return (double) val->integer; }
  virtual my_decimal *val_decimal(Hybrid_type *val, my_decimal *buf) const
  {
    int2my_decimal(E_DEC_FATAL_ERROR, val->integer, 0, &val->dec_buf[2]);
    return &val->dec_buf[2];
  }
  virtual String *val_str(Hybrid_type *val, String *buf, uint8 decimals) const
  { buf->set(val->integer, &my_charset_bin); return buf;}
  static const Hybrid_type_traits_integer *instance();
228
  Hybrid_type_traits_integer() {};
229 230
};

231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250

void dummy_error_processor(THD *thd, void *data);

void view_error_processor(THD *thd, void *data);

/*
  Instances of Name_resolution_context store the information necesary for
  name resolution of Items and other context analysis of a query made in
  fix_fields().

  This structure is a part of SELECT_LEX, a pointer to this structure is
  assigned when an item is created (which happens mostly during  parsing
  (sql_yacc.yy)), but the structure itself will be initialized after parsing
  is complete

  TODO: move subquery of INSERT ... SELECT and CREATE ... SELECT to
  separate SELECT_LEX which allow to remove tricks of changing this
  structure before and after INSERT/CREATE and its SELECT to make correct
  field name resolution.
*/
251
struct Name_resolution_context: Sql_alloc
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
{
  /*
    The name resolution context to search in when an Item cannot be
    resolved in this context (the context of an outer select)
  */
  Name_resolution_context *outer_context;

  /*
    List of tables used to resolve the items of this context.  Usually these
    are tables from the FROM clause of SELECT statement.  The exceptions are
    INSERT ... SELECT and CREATE ... SELECT statements, where SELECT
    subquery is not moved to a separate SELECT_LEX.  For these types of
    statements we have to change this member dynamically to ensure correct
    name resolution of different parts of the statement.
  */
  TABLE_LIST *table_list;
268 269 270 271 272 273 274 275 276 277 278 279 280
  /*
    In most cases the two table references below replace 'table_list' above
    for the purpose of name resolution. The first and last name resolution
    table references allow us to search only in a sub-tree of the nested
    join tree in a FROM clause. This is needed for NATURAL JOIN, JOIN ... USING
    and JOIN ... ON. 
  */
  TABLE_LIST *first_name_resolution_table;
  /*
    Last table to search in the list of leaf table references that begins
    with first_name_resolution_table.
  */
  TABLE_LIST *last_name_resolution_table;
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304

  /*
    SELECT_LEX item belong to, in case of merged VIEW it can differ from
    SELECT_LEX where item was created, so we can't use table_list/field_list
    from there
  */
  st_select_lex *select_lex;

  /*
    Processor of errors caused during Item name resolving, now used only to
    hide underlying tables in errors about views (i.e. it substitute some
    errors for views)
  */
  void (*error_processor)(THD *, void *);
  void *error_processor_data;

  /*
    When TRUE items are resolved in this context both against the
    SELECT list and this->table_list. If FALSE, items are resolved
    only against this->table_list.
  */
  bool resolve_in_select_list;

  /*
305 306
    Security context of this name resolution context. It's used for views
    and is non-zero only if the view is defined with SQL SECURITY DEFINER.
307
  */
308
  Security_context *security_ctx;
309 310 311 312

  Name_resolution_context()
    :outer_context(0), table_list(0), select_lex(0),
    error_processor_data(0),
313
    security_ctx(0)
314 315 316 317 318 319
    {}

  void init()
  {
    resolve_in_select_list= FALSE;
    error_processor= &dummy_error_processor;
320 321
    first_name_resolution_table= NULL;
    last_name_resolution_table= NULL;
322 323 324 325
  }

  void resolve_in_table_list_only(TABLE_LIST *tables)
  {
326
    table_list= first_name_resolution_table= tables;
327 328 329 330 331 332 333 334 335 336
    resolve_in_select_list= FALSE;
  }

  void process_error(THD *thd)
  {
    (*error_processor)(thd, error_processor_data);
  }
};


337 338 339 340 341 342 343 344 345 346 347
/*
  Store and restore the current state of a name resolution context.
*/

class Name_resolution_context_state
{
private:
  TABLE_LIST *save_table_list;
  TABLE_LIST *save_first_name_resolution_table;
  TABLE_LIST *save_next_name_resolution_table;
  bool        save_resolve_in_select_list;
348
  TABLE_LIST *save_next_local;
349 350

public:
351
  Name_resolution_context_state() {}          /* Remove gcc warning */
352 353 354 355 356 357 358 359 360

public:
  /* Save the state of a name resolution context. */
  void save_state(Name_resolution_context *context, TABLE_LIST *table_list)
  {
    save_table_list=                  context->table_list;
    save_first_name_resolution_table= context->first_name_resolution_table;
    save_resolve_in_select_list=      context->resolve_in_select_list;
    save_next_local=                  table_list->next_local;
361
    save_next_name_resolution_table=  table_list->next_name_resolution_table;
362 363 364 365 366 367
  }

  /* Restore a name resolution context from saved state. */
  void restore_state(Name_resolution_context *context, TABLE_LIST *table_list)
  {
    table_list->next_local=                save_next_local;
368
    table_list->next_name_resolution_table= save_next_name_resolution_table;
369 370 371 372
    context->table_list=                   save_table_list;
    context->first_name_resolution_table=  save_first_name_resolution_table;
    context->resolve_in_select_list=       save_resolve_in_select_list;
  }
373 374 375 376 377

  TABLE_LIST *get_first_name_resolution_table()
  {
    return save_first_name_resolution_table;
  }
378 379
};

380 381 382 383 384 385 386 387 388 389 390 391 392

/*
  This enum is used to report information about monotonicity of function
  represented by Item* tree.
  Monotonicity is defined only for Item* trees that represent table
  partitioning expressions (i.e. have no subselects/user vars/PS parameters
  etc etc). An Item* tree is assumed to have the same monotonicity properties
  as its correspoinding function F:

  [signed] longlong F(field1, field2, ...) {
    put values of field_i into table record buffer;
    return item->val_int(); 
  }
393 394 395 396 397 398 399

  NOTE
  At the moment function monotonicity is not well defined (and so may be
  incorrect) for Item trees with parameters/return types that are different
  from INT_RESULT, may be NULL, or are unsigned.
  It will be possible to address this issue once the related partitioning bugs
  (BUG#16002, BUG#15447, BUG#13436) are fixed.
400 401 402 403 404
*/

typedef enum monotonicity_info 
{
   NON_MONOTONIC,              /* none of the below holds */
405 406
   MONOTONIC_INCREASING,       /* F() is unary and (x < y) => (F(x) <= F(y)) */
   MONOTONIC_STRICT_INCREASING /* F() is unary and (x < y) => (F(x) <  F(y)) */
407 408
} enum_monotonicity_info;

409 410
/*************************************************************************/

411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426
class sp_rcontext;


class Settable_routine_parameter
{
public:
  /*
    Set required privileges for accessing the parameter.

    SYNOPSIS
      set_required_privilege()
        rw        if 'rw' is true then we are going to read and set the
                  parameter, so SELECT and UPDATE privileges might be
                  required, otherwise we only reading it and SELECT
                  privilege might be required.
  */
427 428
  Settable_routine_parameter() {}
  virtual ~Settable_routine_parameter() {}
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
  virtual void set_required_privilege(bool rw) {};

  /*
    Set parameter value.

    SYNOPSIS
      set_value()
        thd       thread handle
        ctx       context to which parameter belongs (if it is local
                  variable).
        it        item which represents new value

    RETURN
      FALSE if parameter value has been set,
      TRUE if error has occured.
  */
445
  virtual bool set_value(THD *thd, sp_rcontext *ctx, Item **it)= 0;
446 447 448
};


449
typedef bool (Item::*Item_processor) (uchar *arg);
450 451 452 453 454 455 456 457 458 459 460
/*
  Analyzer function
    SYNOPSIS
      argp   in/out IN:  Analysis parameter
                    OUT: Parameter to be passed to the transformer

    RETURN 
      TRUE   Invoke the transformer
      FALSE  Don't do it

*/
461 462
typedef bool (Item::*Item_analyzer) (uchar **argp);
typedef Item* (Item::*Item_transformer) (uchar *arg);
463
typedef void (*Cond_traverser) (const Item *item, void *arg);
464

465

bk@work.mysql.com's avatar
bk@work.mysql.com committed
466
class Item {
467
  Item(const Item &);			/* Prevent use of these */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
468 469
  void operator=(Item &);
public:
470
  static void *operator new(size_t size) throw ()
471
  { return sql_alloc(size); }
472
  static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
473
  { return alloc_root(mem_root, size); }
474
  static void operator delete(void *ptr,size_t size) { TRASH(ptr, size); }
475
  static void operator delete(void *ptr, MEM_ROOT *mem_root) {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
476

477
  enum Type {FIELD_ITEM= 0, FUNC_ITEM, SUM_FUNC_ITEM, STRING_ITEM,
478
	     INT_ITEM, REAL_ITEM, NULL_ITEM, VARBIN_ITEM,
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
479
	     COPY_STR_ITEM, FIELD_AVG_ITEM, DEFAULT_VALUE_ITEM,
480 481
	     PROC_ITEM,COND_ITEM, REF_ITEM, FIELD_STD_ITEM,
	     FIELD_VARIANCE_ITEM, INSERT_VALUE_ITEM,
482
             SUBSELECT_ITEM, ROW_ITEM, CACHE_ITEM, TYPE_HOLDER,
483
             PARAM_ITEM, TRIGGER_FIELD_ITEM, DECIMAL_ITEM,
484
             XPATH_NODESET, XPATH_NODESET_CMP,
485
             VIEW_FIXER_ITEM};
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
486

bk@work.mysql.com's avatar
bk@work.mysql.com committed
487
  enum cond_result { COND_UNDEF,COND_OK,COND_TRUE,COND_FALSE };
488 489

  enum traverse_order { POSTFIX, PREFIX };
490
  
491 492 493
  /* Reuse size, only used by SP local variable assignment, otherwize 0 */
  uint rsize;

monty@mysql.com's avatar
monty@mysql.com committed
494 495 496 497 498
  /*
    str_values's main purpose is to be used to cache the value in
    save_in_field
  */
  String str_value;
499
  char * name;			/* Name from select */
500
  /* Original item name (if it was renamed)*/
501
  char * orig_name;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
502 503
  Item *next;
  uint32 max_length;
504
  uint name_length;                     /* Length of name */
505 506
  int8 marker;
  uint8 decimals;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
507 508
  my_bool maybe_null;			/* If item may be null */
  my_bool null_value;			/* if item is null */
509
  my_bool unsigned_flag;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
510
  my_bool with_sum_func;
511
  my_bool fixed;                        /* If item fixed with fix_fields */
512 513
  my_bool is_autogenerated_name;        /* indicate was name of this Item
                                           autogenerated or set by user */
514
  DTCollation collation;
515 516 517
  my_bool with_subselect;               /* If this item is a subselect or some
                                           of its arguments is or contains a
                                           subselect */
518
  Item_result cmp_context;              /* Comparison context */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
519 520
  // alloc & destruct is done as start of select using sql_alloc
  Item();
521
  /*
522
     Constructor used by Item_field, Item_ref & aggregate (sum) functions.
523 524
     Used for duplicating lists in processing queries with temporary
     tables
525
     Also it used for Item_cond_and/Item_cond_or for creating
526
     top AND/OR structure of WHERE clause to protect it of
527
     optimisation changes in prepared statements
528
  */
529
  Item(THD *thd, Item *item);
monty@mysql.com's avatar
monty@mysql.com committed
530 531
  virtual ~Item()
  {
monty@mysql.com's avatar
monty@mysql.com committed
532
#ifdef EXTRA_DEBUG
monty@mysql.com's avatar
monty@mysql.com committed
533
    name=0;
monty@mysql.com's avatar
monty@mysql.com committed
534
#endif
monty@mysql.com's avatar
monty@mysql.com committed
535
  }		/*lint -e1509 */
536
  void set_name(const char *str, uint length, CHARSET_INFO *cs);
537
  void rename(char *new_name);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
538
  void init_make_field(Send_field *tmp_field,enum enum_field_types type);
539
  virtual void cleanup();
540
  virtual void make_field(Send_field *field);
541
  Field *make_string_field(TABLE *table);
542
  virtual bool fix_fields(THD *, Item **);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
543
  /*
monty@mysql.com's avatar
monty@mysql.com committed
544
    should be used in case where we are sure that we do not need
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
545 546 547
    complete fix_fields() procedure.
  */
  inline void quick_fix_field() { fixed= 1; }
monty@mysql.com's avatar
monty@mysql.com committed
548
  /* Function returns 1 on overflow and -1 on fatal errors */
549
  int save_in_field_no_warnings(Field *field, bool no_conversions);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
550
  virtual int save_in_field(Field *field, bool no_conversions);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
551
  virtual void save_org_in_field(Field *field)
552
  { (void) save_in_field(field, 1); }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
553
  virtual int save_safe_in_field(Field *field)
554
  { return save_in_field(field, 1); }
555
  virtual bool send(Protocol *protocol, String *str);
556
  virtual bool eq(const Item *, bool binary_cmp) const;
557 558
  virtual Item_result result_type() const { return REAL_RESULT; }
  virtual Item_result cast_to_int_type() const { return result_type(); }
559
  virtual enum_field_types string_field_type() const;
560
  virtual enum_field_types field_type() const;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
561
  virtual enum Type type() const =0;
562 563 564 565 566 567 568 569 570
  
  /*
    Return information about function monotonicity. See comment for
    enum_monotonicity_info for details. This function can only be called
    after fix_fields() call.
  */
  virtual enum_monotonicity_info get_monotonicity_info() const
  { return NON_MONOTONIC; }

571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604
  /*
    Convert "func_arg $CMP$ const" half-interval into "FUNC(func_arg) $CMP2$ const2"

    SYNOPSIS
      val_int_endpoint()
        left_endp  FALSE  <=> The interval is "x < const" or "x <= const"
                   TRUE   <=> The interval is "x > const" or "x >= const"

        incl_endp  IN   TRUE <=> the comparison is '<' or '>'
                        FALSE <=> the comparison is '<=' or '>='
                   OUT  The same but for the "F(x) $CMP$ F(const)" comparison

    DESCRIPTION
      This function is defined only for unary monotonic functions. The caller
      supplies the source half-interval

         x $CMP$ const

      The value of const is supplied implicitly as the value this item's
      argument, the form of $CMP$ comparison is specified through the
      function's arguments. The calle returns the result interval
         
         F(x) $CMP2$ F(const)
      
      passing back F(const) as the return value, and the form of $CMP2$ 
      through the out parameter. NULL values are assumed to be comparable and
      be less than any non-NULL values.

    RETURN
      The output range bound, which equal to the value of val_int()
        - If the value of the function is NULL then the bound is the 
          smallest possible value of LONGLONG_MIN 
  */
  virtual longlong val_int_endpoint(bool left_endp, bool *incl_endp)
605
  { DBUG_ASSERT(0); return 0; }
606 607


608
  /* valXXX methods must return NULL or 0 or 0.0 if null_value is set. */
609 610 611 612 613 614 615 616 617 618
  /*
    Return double precision floating point representation of item.

    SYNOPSIS
      val_real()

    RETURN
      In case of NULL value return 0.0 and set null_value flag to TRUE.
      If value is not null null_value flag will be reset to FALSE.
  */
619
  virtual double val_real()=0;
620 621 622 623 624 625 626 627 628 629
  /*
    Return integer representation of item.

    SYNOPSIS
      val_int()

    RETURN
      In case of NULL value return 0 and set null_value flag to TRUE.
      If value is not null null_value flag will be reset to FALSE.
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
630
  virtual longlong val_int()=0;
631 632 633 634 635
  /*
    This is just a shortcut to avoid the cast. You should still use
    unsigned_flag to check the sign of the item.
  */
  inline ulonglong val_uint() { return (ulonglong) val_int(); }
636 637 638
  /*
    Return string representation of this item object.

639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695
    SYNOPSIS
      val_str()
      str   an allocated buffer this or any nested Item object can use to
            store return value of this method.

    NOTE
      Buffer passed via argument  should only be used if the item itself
      doesn't have an own String buffer. In case when the item maintains
      it's own string buffer, it's preferable to return it instead to
      minimize number of mallocs/memcpys.
      The caller of this method can modify returned string, but only in case
      when it was allocated on heap, (is_alloced() is true).  This allows
      the caller to efficiently use a buffer allocated by a child without
      having to allocate a buffer of it's own. The buffer, given to
      val_str() as argument, belongs to the caller and is later used by the
      caller at it's own choosing.
      A few implications from the above:
      - unless you return a string object which only points to your buffer
        but doesn't manages it you should be ready that it will be
        modified.
      - even for not allocated strings (is_alloced() == false) the caller
        can change charset (see Item_func_{typecast/binary}. XXX: is this
        a bug?
      - still you should try to minimize data copying and return internal
        object whenever possible.

    RETURN
      In case of NULL value return 0 (NULL pointer) and set null_value flag
      to TRUE.
      If value is not null null_value flag will be reset to FALSE.
  */
  virtual String *val_str(String *str)=0;
  /*
    Return decimal representation of item with fixed point.

    SYNOPSIS
      val_decimal()
      decimal_buffer  buffer which can be used by Item for returning value
                      (but can be not)

    NOTE
      Returned value should not be changed if it is not the same which was
      passed via argument.

    RETURN
      Return pointer on my_decimal (it can be other then passed via argument)
        if value is not NULL (null_value flag will be reset to FALSE).
      In case of NULL value it return 0 pointer and set null_value flag
        to TRUE.
  */
  virtual my_decimal *val_decimal(my_decimal *decimal_buffer)= 0;
  /*
    Return boolean value of item.

    RETURN
      FALSE value is false or NULL
      TRUE value is true (not equal to 0)
696
  */
697
  virtual bool val_bool();
698
  virtual String *val_nodeset(String*) { return 0; }
699 700 701 702 703 704 705
  /* Helper functions, see item_sum.cc */
  String *val_string_from_real(String *str);
  String *val_string_from_int(String *str);
  String *val_string_from_decimal(String *str);
  my_decimal *val_decimal_from_real(my_decimal *decimal_value);
  my_decimal *val_decimal_from_int(my_decimal *decimal_value);
  my_decimal *val_decimal_from_string(my_decimal *decimal_value);
706 707
  my_decimal *val_decimal_from_date(my_decimal *decimal_value);
  my_decimal *val_decimal_from_time(my_decimal *decimal_value);
708 709 710
  longlong val_int_from_decimal();
  double val_real_from_decimal();

711 712
  int save_time_in_field(Field *field);
  int save_date_in_field(Field *field);
713
  int save_str_value_in_field(Field *field, String *result);
714

715
  virtual Field *get_tmp_table_field() { return 0; }
sergefp@mysql.com's avatar
sergefp@mysql.com committed
716
  /* This is also used to create fields in CREATE ... SELECT: */
717
  virtual Field *tmp_table_field(TABLE *t_arg) { return 0; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
718
  virtual const char *full_name() const { return name ? name : "???"; }
719 720 721 722 723 724 725

  /*
    *result* family of methods is analog of *val* family (see above) but
    return value of result_field of item if it is present. If Item have not
    result field, it return val(). This methods set null_value flag in same
    way as *val* methods do it.
  */
726
  virtual double  val_result() { return val_real(); }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
727 728
  virtual longlong val_int_result() { return val_int(); }
  virtual String *str_result(String* tmp) { return val_str(tmp); }
729 730 731 732
  virtual my_decimal *val_decimal_result(my_decimal *val)
  { return val_decimal(val); }
  virtual bool val_bool_result() { return val_bool(); }

733
  /* bit map of tables used by item */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
734
  virtual table_map used_tables() const { return (table_map) 0L; }
735 736 737 738 739 740 741 742 743 744 745 746 747 748
  /*
    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
749
    a constant expression. Used in the optimizer to propagate basic constants.
750
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
751
  virtual bool basic_const_item() const { return 0; }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
752
  /* cloning of constant items (0 if it is not const) */
753
  virtual Item *clone_item() { return 0; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
754 755 756
  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;}
757 758 759
  virtual uint decimal_precision() const;
  inline int decimal_int_part() const
  { return my_decimal_int_part(decimal_precision(), decimals); }
760 761 762 763
  /* 
    Returns true if this is constant (during query execution, i.e. its value
    will not change until next fix_fields) and its value is known.
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
764
  virtual bool const_item() const { return used_tables() == 0; }
765 766 767 768 769 770
  /* 
    Returns true if this is constant but its value may be not known yet.
    (Can be used for parameters of prep. stmts or of stored procedures.)
  */
  virtual bool const_during_execution() const 
  { return (used_tables() & ~PARAM_TABLE_BIT) == 0; }
771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788

  /**
    This method is used for to:
      - to generate a view definition query (SELECT-statement);
      - to generate a SQL-query for EXPLAIN EXTENDED;
      - to generate a SQL-query to be shown in INFORMATION_SCHEMA;
      - debug.

    For more information about view definition query, INFORMATION_SCHEMA
    query and why they should be generated from the Item-tree, @see
    mysql_register_view().
  */
  virtual inline void print(String *str, enum_query_type query_type)
  {
    str->append(full_name());
  }

  void print_item_w_name(String *, enum_query_type query_type);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
789
  virtual void update_used_tables() {}
790 791
  virtual void split_sum_func(THD *thd, Item **ref_pointer_array,
                              List<Item> &fields) {}
792 793
  /* Called for items that really have to be split */
  void split_sum_func2(THD *thd, Item **ref_pointer_array, List<Item> &fields,
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
794
                       Item **ref, bool skip_registered);
795 796 797
  virtual bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
  virtual bool get_time(MYSQL_TIME *ltime);
  virtual bool get_date_result(MYSQL_TIME *ltime,uint fuzzydate)
798
  { return get_date(ltime,fuzzydate); }
799
  /*
800 801 802 803 804
    The method allows to determine nullness of a complex expression 
    without fully evaluating it, instead of calling val/result*() then 
    checking null_value. Used in Item_func_isnull/Item_func_isnotnull
    and Item_sum_count/Item_sum_count_distinct.
    Any new item which can be NULL must implement this method.
805
  */
806
  virtual bool is_null() { return 0; }
807

808 809 810 811 812
  /*
   Make sure the null_value member has a correct value.
  */
  virtual void update_null_value () { (void) val_int(); }

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
813
  /*
814 815 816 817 818 819 820 821
    Inform the item that there will be no distinction between its result
    being FALSE or NULL.

    NOTE
      This function will be called for eg. Items that are top-level AND-parts
      of the WHERE clause. Items implementing this function (currently
      Item_cond_and and subquery-related item) enable special optimizations
      when they are "top level".
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
822
  */
823
  virtual void top_level_item() {}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
824 825
  /*
    set field of temporary table for Item which can be switched on temporary
826
    table during query processing (grouping and so on)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
827
  */
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
828 829
  virtual void set_result_field(Field *field) {}
  virtual bool is_result_field() { return 0; }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
830
  virtual bool is_bool_func() { return 0; }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
831
  virtual void save_in_result_field(bool no_conversions) {}
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
832
  /*
833
    set value of aggregate function in case of no rows for grouping were found
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
834
  */
835
  virtual void no_rows_in_result() {}
836
  virtual Item *copy_or_same(THD *thd) { return this; }
837
  virtual Item *copy_andor_structure(THD *thd) { return this; }
838
  virtual Item *real_item() { return this; }
839
  virtual Item *get_tmp_table_item(THD *thd) { return copy_or_same(thd); }
840

841
  static CHARSET_INFO *default_charset();
842
  virtual CHARSET_INFO *compare_collation() { return NULL; }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
843

844
  virtual bool walk(Item_processor processor, bool walk_subquery, uchar *arg)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
845 846 847 848
  {
    return (this->*processor)(arg);
  }

849
  virtual Item* transform(Item_transformer transformer, uchar *arg);
850

851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866
  /*
    This function performs a generic "compilation" of the Item tree.
    The process of compilation is assumed to go as follows: 
    
    compile()
    { 
      if (this->*some_analyzer(...))
      {
        compile children if any;
        this->*some_transformer(...);
      }
    }

    i.e. analysis is performed top-down while transformation is done
    bottom-up.      
  */
867 868
  virtual Item* compile(Item_analyzer analyzer, uchar **arg_p,
                        Item_transformer transformer, uchar *arg_t)
869 870 871 872 873 874
  {
    if ((this->*analyzer) (arg_p))
      return ((this->*transformer) (arg_t));
    return 0;
  }

875 876
   virtual void traverse_cond(Cond_traverser traverser,
                              void *arg, traverse_order order)
877 878 879
   {
     (*traverser)(this, arg);
   }
880

881 882 883 884 885 886 887 888 889
  virtual bool remove_dependence_processor(uchar * arg) { return 0; }
  virtual bool remove_fixed(uchar * arg) { fixed= 0; return 0; }
  virtual bool cleanup_processor(uchar *arg);
  virtual bool collect_item_field_processor(uchar * arg) { return 0; }
  virtual bool find_item_in_field_list_processor(uchar *arg) { return 0; }
  virtual bool change_context_processor(uchar *context) { return 0; }
  virtual bool reset_query_id_processor(uchar *query_id_arg) { return 0; }
  virtual bool is_expensive_processor(uchar *arg) { return 0; }
  virtual bool register_field_in_read_map(uchar *arg) { return 0; }
890
  /*
891 892 893
    Check if a partition function is allowed
    SYNOPSIS
      check_partition_func_processor()
894
      int_arg                        Ignored
895
    RETURN VALUE
896 897 898
      TRUE                           Partition function not accepted
      FALSE                          Partition function accepted

899
    DESCRIPTION
900
    check_partition_func_processor is used to check if a partition function
901 902 903 904 905 906 907
    uses an allowed function. An allowed function will always ensure that
    X=Y guarantees that also part_function(X)=part_function(Y) where X is
    a set of partition fields and so is Y. The problems comes mainly from
    character sets where two equal strings can be quite unequal. E.g. the
    german character for double s is equal to 2 s.

    The default is that an item is not allowed
908
    in a partition function. Allowed functions
909 910 911 912 913 914 915 916
    can never depend on server version, they cannot depend on anything
    related to the environment. They can also only depend on a set of
    fields in the table itself. They cannot depend on other tables and
    cannot contain any queries and cannot contain udf's or similar.
    If a new Item class is defined and it inherits from a class that is
    allowed in a partition function then it is very important to consider
    whether this should be inherited to the new class. If not the function
    below should be defined in the new Item class.
mikael/pappa@dator5.(none)'s avatar
mikael/pappa@dator5.(none) committed
917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939

    The general behaviour is that most integer functions are allowed.
    If the partition function contains any multi-byte collations then
    the function check_part_func_fields will report an error on the
    partition function independent of what functions are used. So the
    only character sets allowed are single character collation and
    even for those only a limited set of functions are allowed. The
    problem with multi-byte collations is that almost every string
    function has the ability to change things such that two strings
    that are equal will not be equal after manipulated by a string
    function. E.g. two strings one contains a double s, there is a
    special german character that is equal to two s. Now assume a
    string function removes one character at this place, then in
    one the double s will be removed and in the other there will
    still be one s remaining and the strings are no longer equal
    and thus the partition function will not sort equal strings into
    the same partitions.

    So the check if a partition function is valid is two steps. First
    check that the field types are valid, next check that the partition
    function is valid. The current set of partition functions valid
    assumes that there are no multi-byte collations amongst the partition
    fields.
940
  */
941 942
  virtual bool check_partition_func_processor(uchar *bool_arg) { return TRUE;}
  virtual bool subst_argument_checker(uchar **arg)
943 944 945 946 947
  { 
    if (*arg)
      *arg= NULL; 
    return TRUE;     
  }
948

949 950 951
  virtual Item *equal_fields_propagator(uchar * arg) { return this; }
  virtual bool set_no_const_sub(uchar *arg) { return FALSE; }
  virtual Item *replace_equal_field(uchar * arg) { return this; }
952 953 954 955 956 957

  /*
    For SP local variable returns pointer to Item representing its
    current value and pointer to current Item otherwise.
  */
  virtual Item *this_item() { return this; }
958 959
  virtual const Item *this_item() const { return this; }

960 961 962 963
  /*
    For SP local variable returns address of pointer to Item representing its
    current value and pointer passed via parameter otherwise.
  */
964
  virtual Item **this_item_addr(THD *thd, Item **addr_arg) { return addr_arg; }
965 966 967

  // Row emulation
  virtual uint cols() { return 1; }
968
  virtual Item* element_index(uint i) { return this; }
969
  virtual Item** addr(uint i) { return 0; }
970
  virtual bool check_cols(uint c);
971
  // It is not row => null inside is impossible
972 973 974
  virtual bool null_inside() { return 0; }
  // used in row subselects to get value of elements
  virtual void bring_value() {}
975

976
  Field *tmp_table_field_from_field_type(TABLE *table, bool fixed_length);
977
  virtual Item_field *filed_for_view_update() { return 0; }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
978

979
  virtual Item *neg_transformer(THD *thd) { return NULL; }
980
  virtual Item *update_value_transformer(uchar *select_arg) { return this; }
bar@mysql.com's avatar
bar@mysql.com committed
981
  virtual Item *safe_charset_converter(CHARSET_INFO *tocs);
982 983 984 985
  void delete_self()
  {
    cleanup();
    delete this;
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
986
  }
987 988

  virtual bool is_splocal() { return 0; } /* Needed for error checking */
989 990 991 992 993 994 995 996 997

  /*
    Return Settable_routine_parameter interface of the Item.  Return 0
    if this Item is not Settable_routine_parameter.
  */
  virtual Settable_routine_parameter *get_settable_routine_parameter()
  {
    return 0;
  }
998 999 1000 1001 1002 1003 1004 1005
  /*
    result_as_longlong() must return TRUE for Items representing DATE/TIME
    functions and DATE/TIME table fields.
    Those Items have result_type()==STRING_RESULT (and not INT_RESULT), but
    their values should be compared as integers (because the integer
    representation is more precise than the string one).
  */
  virtual bool result_as_longlong() { return FALSE; }
1006
  bool is_datetime();
1007 1008
  virtual Field::geometry_type get_geometry_type() const
    { return Field::GEOM_GEOMETRY; };
1009
  String *check_well_formed_result(String *str, bool send_error= 0);
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
1010
  bool eq_by_collation(Item *item, bool binary_cmp, CHARSET_INFO *cs); 
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1011 1012 1013
};


1014 1015
class sp_head;

1016

1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
class Item_basic_constant :public Item
{
public:
  /* to prevent drop fixed flag (no need parent cleanup call) */
  void cleanup()
  {
    /*
      Restore the original field name as it might not have been allocated
      in the statement memory. If the name is auto generated, it must be
      done again between subsequent executions of a prepared statement.
    */
    if (orig_name)
      name= orig_name;
  }
};


1034 1035 1036 1037 1038 1039 1040 1041
/*****************************************************************************
  The class is a base class for representation of stored routine variables in
  the Item-hierarchy. There are the following kinds of SP-vars:
    - local variables (Item_splocal);
    - CASE expression (Item_case_expr);
*****************************************************************************/

class Item_sp_variable :public Item
1042
{
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
protected:
  /*
    THD, which is stored in fix_fields() and is used in this_item() to avoid
    current_thd use.
  */
  THD *m_thd;

public:
  LEX_STRING m_name;

1053
public:
1054 1055 1056 1057 1058
#ifndef DBUG_OFF
  /*
    Routine to which this Item_splocal belongs. Used for checking if correct
    runtime context is used for variable handling.
  */
1059
  sp_head *m_sp;
1060
#endif
1061

1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
public:
  Item_sp_variable(char *sp_var_name_str, uint sp_var_name_length);

public:
  bool fix_fields(THD *thd, Item **);

  double val_real();
  longlong val_int();
  String *val_str(String *sp);
  my_decimal *val_decimal(my_decimal *decimal_value);
  bool is_null();

public:
  inline void make_field(Send_field *field);
  
  inline bool const_item() const;
  
  inline int save_in_field(Field *field, bool no_conversions);
  inline bool send(Protocol *protocol, String *str);
}; 

/*****************************************************************************
  Item_sp_variable inline implementation.
*****************************************************************************/

inline void Item_sp_variable::make_field(Send_field *field)
{
  Item *it= this_item();

  if (name)
    it->set_name(name, (uint) strlen(name), system_charset_info);
  else
    it->set_name(m_name.str, m_name.length, system_charset_info);
  it->make_field(field);
}

inline bool Item_sp_variable::const_item() const
{
  return TRUE;
}

inline int Item_sp_variable::save_in_field(Field *field, bool no_conversions)
{
  return this_item()->save_in_field(field, no_conversions);
}

inline bool Item_sp_variable::send(Protocol *protocol, String *str)
{
  return this_item()->send(protocol, str);
}


/*****************************************************************************
  A reference to local SP variable (incl. reference to SP parameter), used in
  runtime.
*****************************************************************************/

1119 1120
class Item_splocal :public Item_sp_variable,
                    private Settable_routine_parameter
1121 1122 1123 1124 1125
{
  uint m_var_idx;

  Type m_type;
  Item_result m_result_type;
1126
  enum_field_types m_field_type;
1127
public:
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
  /* 
    Position of this reference to SP variable in the statement (the
    statement itself is in sp_instr_stmt::m_query).
    This is valid only for references to SP variables in statements,
    excluding DECLARE CURSOR statement. It is used to replace references to SP
    variables with NAME_CONST calls when putting statements into the binary
    log.
    Value of 0 means that this object doesn't corresponding to reference to
    SP variable in query text.
  */
1138
  uint pos_in_query;
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
1139 1140 1141 1142 1143 1144 1145 1146
  /*
    Byte length of SP variable name in the statement (see pos_in_query).
    The value of this field may differ from the name_length value because
    name_length contains byte length of UTF8-encoded item name, but
    the query string (see sp_instr_stmt::m_query) is currently stored with
    a charset from the SET NAMES statement.
  */
  uint len_in_query;
1147

1148
  Item_splocal(const LEX_STRING &sp_var_name, uint sp_var_idx,
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
1149 1150
               enum_field_types sp_var_type,
               uint pos_in_q= 0, uint len_in_q= 0);
1151

1152 1153
  bool is_splocal() { return 1; } /* Needed for error checking */

1154
  Item *this_item();
1155
  const Item *this_item() const;
1156
  Item **this_item_addr(THD *thd, Item **);
1157

1158
  virtual void print(String *str, enum_query_type query_type);
1159

1160 1161
public:
  inline const LEX_STRING *my_name() const;
1162

1163
  inline uint get_var_idx() const;
1164

1165 1166
  inline enum Type type() const;
  inline Item_result result_type() const;
1167
  inline enum_field_types field_type() const { return m_field_type; }
1168 1169

private:
1170
  bool set_value(THD *thd, sp_rcontext *ctx, Item **it);
1171 1172 1173 1174 1175 1176

public:
  Settable_routine_parameter *get_settable_routine_parameter()
  {
    return this;
  }
1177
};
1178

1179 1180 1181
/*****************************************************************************
  Item_splocal inline implementation.
*****************************************************************************/
1182

1183 1184 1185 1186
inline const LEX_STRING *Item_splocal::my_name() const
{
  return &m_name;
}
1187

1188 1189 1190 1191
inline uint Item_splocal::get_var_idx() const
{
  return m_var_idx;
}
1192

1193 1194 1195 1196
inline enum Item::Type Item_splocal::type() const
{
  return m_type;
}
1197

1198 1199 1200 1201
inline Item_result Item_splocal::result_type() const
{
  return m_result_type;
}
1202

1203 1204 1205 1206 1207 1208 1209 1210

/*****************************************************************************
  A reference to case expression in SP, used in runtime.
*****************************************************************************/

class Item_case_expr :public Item_sp_variable
{
public:
1211
  Item_case_expr(uint case_expr_id);
1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226

public:
  Item *this_item();
  const Item *this_item() const;
  Item **this_item_addr(THD *thd, Item **);

  inline enum Type type() const;
  inline Item_result result_type() const;

public:
  /*
    NOTE: print() is intended to be used from views and for debug.
    Item_case_expr can not occur in views, so here it is only for debug
    purposes.
  */
1227
  virtual void print(String *str, enum_query_type query_type);
1228 1229

private:
1230
  uint m_case_expr_id;
1231 1232
};

1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
/*****************************************************************************
  Item_case_expr inline implementation.
*****************************************************************************/

inline enum Item::Type Item_case_expr::type() const
{
  return this_item()->type();
}

inline Item_result Item_case_expr::result_type() const
{
  return this_item()->result_type();
}

1247

1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265
/*
  NAME_CONST(given_name, const_value). 
  This 'function' has all properties of the supplied const_value (which is 
  assumed to be a literal constant), and the name given_name. 

  This is used to replace references to SP variables when we write PROCEDURE
  statements into the binary log.

  TODO
    Together with Item_splocal and Item::this_item() we can actually extract
    common a base of this class and Item_splocal. Maybe it is possible to
    extract a common base with class Item_ref, too.
*/

class Item_name_const : public Item
{
  Item *value_item;
  Item *name_item;
1266
  bool valid_args;
1267
public:
1268
  Item_name_const(Item *name_arg, Item *val);
1269 1270 1271 1272 1273 1274 1275 1276 1277

  bool fix_fields(THD *, Item **);

  enum Type type() const;
  double val_real();
  longlong val_int();
  String *val_str(String *sp);
  my_decimal *val_decimal(my_decimal *);
  bool is_null();
1278
  virtual void print(String *str, enum_query_type query_type);
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294

  Item_result result_type() const
  {
    return value_item->result_type();
  }

  bool const_item() const
  {
    return TRUE;
  }

  int save_in_field(Field *field, bool no_conversions)
  {
    return  value_item->save_in_field(field, no_conversions);
  }

1295
  bool send(Protocol *protocol, String *str)
1296 1297 1298 1299 1300
  {
    return value_item->send(protocol, str);
  }
};

1301
bool agg_item_collations(DTCollation &c, const char *name,
1302
                         Item **items, uint nitems, uint flags, int item_sep);
1303
bool agg_item_collations_for_comparison(DTCollation &c, const char *name,
1304
                                        Item **items, uint nitems, uint flags);
1305
bool agg_item_charsets(DTCollation &c, const char *name,
1306
                       Item **items, uint nitems, uint flags, int item_sep);
1307 1308


1309
class Item_num: public Item_basic_constant
1310 1311
{
public:
1312
  Item_num() {}                               /* Remove gcc warning */
monty@mysql.com's avatar
monty@mysql.com committed
1313
  virtual Item_num *neg()= 0;
bar@mysql.com's avatar
bar@mysql.com committed
1314
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1315
  bool check_partition_func_processor(uchar *int_arg) { return FALSE;}
1316 1317
};

1318
#define NO_CACHED_FIELD_INDEX ((uint)(-1))
1319

1320
class st_select_lex;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1321 1322
class Item_ident :public Item
{
1323
protected:
1324 1325 1326 1327 1328 1329 1330 1331 1332
  /* 
    We have to store initial values of db_name, table_name and field_name
    to be able to restore them during cleanup() because they can be 
    updated during fix_fields() to values from Field object and life-time 
    of those is shorter than life-time of Item_field.
  */
  const char *orig_db_name;
  const char *orig_table_name;
  const char *orig_field_name;
1333

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1334
public:
1335
  Name_resolution_context *context;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1336 1337 1338
  const char *db_name;
  const char *table_name;
  const char *field_name;
1339
  bool alias_name_used; /* true if item was resolved against alias */
1340 1341
  /* 
    Cached value of index for this field in table->field array, used by prep. 
1342 1343 1344 1345 1346 1347 1348 1349
    stmts for speeding up their re-execution. Holds NO_CACHED_FIELD_INDEX 
    if index value is not known.
  */
  uint cached_field_index;
  /*
    Cached pointer to table which contains this field, used for the same reason
    by prep. stmt. too in case then we have not-fully qualified field.
    0 - means no cached value.
1350
  */
1351
  TABLE_LIST *cached_table;
1352
  st_select_lex *depended_from;
1353 1354 1355
  Item_ident(Name_resolution_context *context_arg,
             const char *db_name_arg, const char *table_name_arg,
             const char *field_name_arg);
pem@mysql.com's avatar
pem@mysql.com committed
1356
  Item_ident(THD *thd, Item_ident *item);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1357
  const char *full_name() const;
1358
  void cleanup();
1359
  bool remove_dependence_processor(uchar * arg);
1360
  virtual void print(String *str, enum_query_type query_type);
1361
  virtual bool change_context_processor(uchar *cntx)
1362
    { context= (Name_resolution_context *)cntx; return FALSE; }
1363 1364 1365 1366
  friend bool insert_fields(THD *thd, Name_resolution_context *context,
                            const char *db_name,
                            const char *table_name, List_iterator<Item> *it,
                            bool any_privileges);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1367 1368
};

1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390

class Item_ident_for_show :public Item
{
public:
  Field *field;
  const char *db_name;
  const char *table_name;

  Item_ident_for_show(Field *par_field, const char *db_arg,
                      const char *table_name_arg)
    :field(par_field), db_name(db_arg), table_name(table_name_arg)
  {}

  enum Type type() const { return FIELD_ITEM; }
  double val_real() { return field->val_real(); }
  longlong val_int() { return field->val_int(); }
  String *val_str(String *str) { return field->val_str(str); }
  my_decimal *val_decimal(my_decimal *dec) { return field->val_decimal(dec); }
  void make_field(Send_field *tmp_field);
};


1391 1392
class Item_equal;
class COND_EQUAL;
1393

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1394 1395
class Item_field :public Item_ident
{
1396
protected:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1397 1398 1399
  void set_field(Field *field);
public:
  Field *field,*result_field;
1400 1401
  Item_equal *item_equal;
  bool no_const_subst;
bell@sanja.is.com.ua's avatar
VIEW  
bell@sanja.is.com.ua committed
1402 1403 1404 1405 1406 1407 1408
  /*
    if any_privileges set to TRUE then here real effective privileges will
    be stored
  */
  uint have_privileges;
  /* field need any privileges (for VIEW creation) */
  bool any_privileges;
1409 1410 1411
  Item_field(Name_resolution_context *context_arg,
             const char *db_arg,const char *table_name_arg,
	     const char *field_name_arg);
1412 1413 1414
  /*
    Constructor needed to process subselect with temporary tables (see Item)
  */
1415
  Item_field(THD *thd, Item_field *item);
1416
  /*
1417 1418 1419
    Constructor used inside setup_wild(), ensures that field, table,
    and database names will live as long as Item_field (this is important
    in prepared statements).
1420
  */
1421
  Item_field(THD *thd, Name_resolution_context *context_arg, Field *field);
1422 1423 1424
  /*
    If this constructor is used, fix_fields() won't work, because
    db_name, table_name and column_name are unknown. It's necessary to call
1425
    reset_field() before fix_fields() for all fields created this way.
1426
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1427 1428
  Item_field(Field *field);
  enum Type type() const { return FIELD_ITEM; }
1429
  bool eq(const Item *item, bool binary_cmp) const;
1430
  double val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1431
  longlong val_int();
1432
  my_decimal *val_decimal(my_decimal *);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1433 1434 1435 1436
  String *val_str(String*);
  double val_result();
  longlong val_int_result();
  String *str_result(String* tmp);
1437 1438
  my_decimal *val_decimal_result(my_decimal *);
  bool val_bool_result();
1439
  bool send(Protocol *protocol, String *str_arg);
1440
  void reset_field(Field *f);
1441
  bool fix_fields(THD *, Item **);
1442
  void make_field(Send_field *tmp_field);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1443
  int save_in_field(Field *field,bool no_conversions);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1444 1445 1446 1447 1448 1449
  void save_org_in_field(Field *field);
  table_map used_tables() const;
  enum Item_result result_type () const
  {
    return field->result_type();
  }
1450 1451 1452 1453
  Item_result cast_to_int_type() const
  {
    return field->cast_to_int_type();
  }
1454
  enum_field_types field_type() const
1455 1456 1457
  {
    return field->type();
  }
1458 1459 1460 1461
  enum_monotonicity_info get_monotonicity_info() const
  {
    return MONOTONIC_STRICT_INCREASING;
  }
1462
  longlong val_int_endpoint(bool left_endp, bool *incl_endp);
1463
  Field *get_tmp_table_field() { return result_field; }
1464
  Field *tmp_table_field(TABLE *t_arg) { return result_field; }
1465 1466 1467
  bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
  bool get_date_result(MYSQL_TIME *ltime,uint fuzzydate);
  bool get_time(MYSQL_TIME *ltime);
1468
  bool is_null() { return field->is_null(); }
1469
  void update_null_value();
1470
  Item *get_tmp_table_item(THD *thd);
1471 1472 1473 1474
  bool collect_item_field_processor(uchar * arg);
  bool find_item_in_field_list_processor(uchar *arg);
  bool register_field_in_read_map(uchar *arg);
  bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
hf@deer.(none)'s avatar
hf@deer.(none) committed
1475
  void cleanup();
1476 1477 1478 1479
  bool result_as_longlong()
  {
    return field->can_be_compared_as_longlong();
  }
1480
  Item_equal *find_item_equal(COND_EQUAL *cond_equal);
1481 1482 1483 1484
  bool subst_argument_checker(uchar **arg);
  Item *equal_fields_propagator(uchar *arg);
  bool set_no_const_sub(uchar *arg);
  Item *replace_equal_field(uchar *arg);
1485
  inline uint32 max_disp_length() { return field->max_display_length(); }
1486
  Item_field *filed_for_view_update() { return this; }
monty@mysql.com's avatar
monty@mysql.com committed
1487
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1488
  int fix_outer_field(THD *thd, Field **field, Item **reference);
1489
  virtual Item *update_value_transformer(uchar *select_arg);
1490
  virtual void print(String *str, enum_query_type query_type);
1491
  Field::geometry_type get_geometry_type() const
1492 1493 1494 1495
  {
    DBUG_ASSERT(field_type() == MYSQL_TYPE_GEOMETRY);
    return field->get_geometry_type();
  }
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
1496
  friend class Item_default_value;
1497
  friend class Item_insert_value;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1498
  friend class st_select_lex_unit;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1499 1500
};

1501
class Item_null :public Item_basic_constant
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1502 1503 1504
{
public:
  Item_null(char *name_par=0)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1505 1506 1507 1508 1509
  {
    maybe_null= null_value= TRUE;
    max_length= 0;
    name= name_par ? name_par : (char*) "NULL";
    fixed= 1;
1510
    collation.set(&my_charset_bin, DERIVATION_IGNORABLE);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1511
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1512
  enum Type type() const { return NULL_ITEM; }
1513
  bool eq(const Item *item, bool binary_cmp) const;
1514
  double val_real();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1515 1516
  longlong val_int();
  String *val_str(String *str);
1517
  my_decimal *val_decimal(my_decimal *);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1518
  int save_in_field(Field *field, bool no_conversions);
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1519
  int save_safe_in_field(Field *field);
hf@deer.mysql.r18.ru's avatar
hf@deer.mysql.r18.ru committed
1520
  bool send(Protocol *protocol, String *str);
1521 1522
  enum Item_result result_type () const { return STRING_RESULT; }
  enum_field_types field_type() const   { return MYSQL_TYPE_NULL; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1523
  bool basic_const_item() const { return 1; }
1524
  Item *clone_item() { return new Item_null(name); }
1525
  bool is_null() { return 1; }
1526 1527 1528 1529 1530 1531

  virtual inline void print(String *str, enum_query_type query_type)
  {
    str->append(STRING_WITH_LEN("NULL"));
  }

bar@mysql.com's avatar
bar@mysql.com committed
1532
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1533
  bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1534 1535
};

1536 1537 1538 1539 1540 1541 1542 1543 1544 1545
class Item_null_result :public Item_null
{
public:
  Field *result_field;
  Item_null_result() : Item_null(), result_field(0) {}
  bool is_result_field() { return result_field != 0; }
  void save_in_result_field(bool no_conversions)
  {
    save_in_field(result_field, no_conversions);
  }
1546
  bool check_partition_func_processor(uchar *int_arg) {return TRUE;}
1547
};  
1548 1549 1550

/* Item represents one placeholder ('?') of prepared statement */

1551 1552
class Item_param :public Item
{
bar@mysql.com's avatar
bar@mysql.com committed
1553 1554 1555 1556
  char cnvbuf[MAX_FIELD_WIDTH];
  String cnvstr;
  Item *cnvitem;

1557
public:
1558 1559 1560
  enum enum_item_param_state
  {
    NO_VALUE, NULL_VALUE, INT_VALUE, REAL_VALUE,
1561 1562
    STRING_VALUE, TIME_VALUE, LONG_DATA_VALUE,
    DECIMAL_VALUE
1563 1564
  } state;

1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575
  /*
    A buffer for string and long data values. Historically all allocated
    values returned from val_str() were treated as eligible to
    modification. I. e. in some cases Item_func_concat can append it's
    second argument to return value of the first one. Because of that we
    can't return the original buffer holding string data from val_str(),
    and have to have one buffer for data and another just pointing to
    the data. This is the latter one and it's returned from val_str().
    Can not be declared inside the union as it's not a POD type.
  */
  String str_value_ptr;
1576
  my_decimal decimal_value;
1577 1578
  union
  {
1579 1580
    longlong integer;
    double   real;
1581 1582 1583 1584 1585 1586 1587 1588 1589
    /*
      Character sets conversion info for string values.
      Character sets of client and connection defined at bind time are used
      for all conversions, even if one of them is later changed (i.e.
      between subsequent calls to mysql_stmt_execute).
    */
    struct CONVERSION_INFO
    {
      CHARSET_INFO *character_set_client;
1590
      CHARSET_INFO *character_set_of_placeholder;
1591 1592 1593
      /*
        This points at character set of connection if conversion
        to it is required (i. e. if placeholder typecode is not BLOB).
1594
        Otherwise it's equal to character_set_client (to simplify
1595 1596 1597 1598
        check in convert_str_value()).
      */
      CHARSET_INFO *final_character_set_of_str_value;
    } cs_info;
1599
    MYSQL_TIME     time;
1600 1601 1602
  } value;

  /* Cached values for virtual methods to save us one switch.  */
1603 1604
  enum Item_result item_result_type;
  enum Type item_type;
1605 1606 1607 1608 1609 1610 1611 1612 1613 1614

  /*
    Used when this item is used in a temporary table.
    This is NOT placeholder metadata sent to client, as this value
    is assigned after sending metadata (in setup_one_conversion_function).
    For example in case of 'SELECT ?' you'll get MYSQL_TYPE_STRING both
    in result set and placeholders metadata, no matter what type you will
    supply for this placeholder in mysql_stmt_execute.
  */
  enum enum_field_types param_type;
1615
  /*
1616 1617
    Offset of placeholder inside statement text. Used to create
    no-placeholders version of this statement for the binary log.
1618
  */
1619
  uint pos_in_query;
1620

1621 1622 1623
  Item_param(uint pos_in_query_arg);

  enum Item_result result_type () const { return item_result_type; }
1624
  enum Type type() const { return item_type; }
1625
  enum_field_types field_type() const { return param_type; }
1626

1627
  double val_real();
1628
  longlong val_int();
1629
  my_decimal *val_decimal(my_decimal*);
1630
  String *val_str(String*);
1631 1632
  bool get_time(MYSQL_TIME *tm);
  bool get_date(MYSQL_TIME *tm, uint fuzzydate);
venu@myvenu.com's avatar
venu@myvenu.com committed
1633
  int  save_in_field(Field *field, bool no_conversions);
1634

1635
  void set_null();
1636
  void set_int(longlong i, uint32 max_length_arg);
1637
  void set_double(double i);
1638
  void set_decimal(const char *str, ulong length);
1639 1640
  bool set_str(const char *str, ulong length);
  bool set_longdata(const char *str, ulong length);
1641
  void set_time(MYSQL_TIME *tm, timestamp_type type, uint32 max_length_arg);
1642
  bool set_from_user_var(THD *thd, const user_var_entry *entry);
1643
  void reset();
1644 1645 1646 1647 1648 1649 1650 1651
  /*
    Assign placeholder value from bind data.
    Note, that 'len' has different semantics in embedded library (as we
    don't need to check that packet is not broken there). See
    sql_prepare.cc for details.
  */
  void (*set_param_func)(Item_param *param, uchar **pos, ulong len);

1652 1653 1654
  const String *query_val_str(String *str) const;

  bool convert_str_value(THD *thd);
1655 1656 1657 1658

  /*
    If value for parameter was not set we treat it as non-const
    so noone will use parameters value in fix_fields still
1659 1660 1661
    parameter is constant during execution.
  */
  virtual table_map used_tables() const
1662
  { return state != NO_VALUE ? (table_map)0 : PARAM_TABLE_BIT; }
1663
  virtual void print(String *str, enum_query_type query_type);
1664 1665
  bool is_null()
  { DBUG_ASSERT(state != NO_VALUE); return state == NULL_VALUE; }
1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676
  bool basic_const_item() const;
  /*
    This method is used to make a copy of a basic constant item when
    propagating constants in the optimizer. The reason to create a new
    item and not use the existing one is not precisely known (2005/04/16).
    Probably we are trying to preserve tree structure of items, in other
    words, avoid pointing at one item from two different nodes of the tree.
    Return a new basic constant item if parameter value is a basic
    constant, assert otherwise. This method is called only if
    basic_const_item returned TRUE.
  */
1677
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1678
  Item *clone_item();
1679 1680 1681 1682 1683 1684
  /*
    Implement by-value equality evaluation if parameter value
    is set and is a basic constant (integer, real or string).
    Otherwise return FALSE.
  */
  bool eq(const Item *item, bool binary_cmp) const;
1685 1686
  /** Item is a argument to a limit clause. */
  bool limit_clause_param;
1687
  void set_param_type_and_swap_value(Item_param *from);
1688
};
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1689

1690

1691
class Item_int :public Item_num
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1692 1693
{
public:
1694
  longlong value;
1695 1696
  Item_int(int32 i,uint length= MY_INT32_NUM_DECIMAL_DIGITS)
    :value((longlong) i)
1697
    { max_length=length; fixed= 1; }
1698 1699
  Item_int(longlong i,uint length= MY_INT64_NUM_DECIMAL_DIGITS)
    :value(i)
1700
    { max_length=length; fixed= 1; }
1701 1702
  Item_int(ulonglong i, uint length= MY_INT64_NUM_DECIMAL_DIGITS)
    :value((longlong)i)
1703
    { max_length=length; fixed= 1; unsigned_flag= 1; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1704
  Item_int(const char *str_arg,longlong i,uint length) :value(i)
1705
    { max_length=length; name=(char*) str_arg; fixed= 1; }
monty@mysql.com's avatar
monty@mysql.com committed
1706
  Item_int(const char *str_arg, uint length=64);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1707
  enum Type type() const { return INT_ITEM; }
1708 1709
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types field_type() const { return MYSQL_TYPE_LONGLONG; }
1710
  longlong val_int() { DBUG_ASSERT(fixed == 1); return value; }
1711
  double val_real() { DBUG_ASSERT(fixed == 1); return (double) value; }
1712
  my_decimal *val_decimal(my_decimal *);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1713
  String *val_str(String*);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1714
  int save_in_field(Field *field, bool no_conversions);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1715
  bool basic_const_item() const { return 1; }
1716
  Item *clone_item() { return new Item_int(name,value,max_length); }
1717
  virtual void print(String *str, enum_query_type query_type);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1718
  Item_num *neg() { value= -value; return this; }
1719 1720
  uint decimal_precision() const
  { return (uint)(max_length - test(value < 0)); }
1721
  bool eq(const Item *, bool binary_cmp) const;
mikael@dator6.(none)'s avatar
mikael@dator6.(none) committed
1722
  bool check_partition_func_processor(uchar *bool_arg) { return FALSE;}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1723 1724 1725
};


1726 1727 1728
class Item_uint :public Item_int
{
public:
monty@mysql.com's avatar
monty@mysql.com committed
1729
  Item_uint(const char *str_arg, uint length);
1730
  Item_uint(ulonglong i) :Item_int((ulonglong) i, 10) {}
1731
  Item_uint(const char *str_arg, longlong i, uint length);
1732
  double val_real()
1733
    { DBUG_ASSERT(fixed == 1); return ulonglong2double((ulonglong)value); }
1734
  String *val_str(String*);
1735
  Item *clone_item() { return new Item_uint(name, value, max_length); }
monty@mysql.com's avatar
monty@mysql.com committed
1736
  int save_in_field(Field *field, bool no_conversions);
1737
  virtual void print(String *str, enum_query_type query_type);
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1738
  Item_num *neg ();
1739
  uint decimal_precision() const { return max_length; }
mikael@dator6.(none)'s avatar
mikael@dator6.(none) committed
1740
  bool check_partition_func_processor(uchar *bool_arg) { return FALSE;}
1741 1742 1743
};


1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755
/* decimal (fixed point) constant */
class Item_decimal :public Item_num
{
protected:
  my_decimal decimal_value;
public:
  Item_decimal(const char *str_arg, uint length, CHARSET_INFO *charset);
  Item_decimal(const char *str, const my_decimal *val_arg,
               uint decimal_par, uint length);
  Item_decimal(my_decimal *value_par);
  Item_decimal(longlong val, bool unsig);
  Item_decimal(double val, int precision, int scale);
1756
  Item_decimal(const uchar *bin, int precision, int scale);
1757 1758 1759 1760 1761 1762 1763 1764 1765 1766

  enum Type type() const { return DECIMAL_ITEM; }
  enum Item_result result_type () const { return DECIMAL_RESULT; }
  enum_field_types field_type() const { return MYSQL_TYPE_NEWDECIMAL; }
  longlong val_int();
  double val_real();
  String *val_str(String*);
  my_decimal *val_decimal(my_decimal *val) { return &decimal_value; }
  int save_in_field(Field *field, bool no_conversions);
  bool basic_const_item() const { return 1; }
1767
  Item *clone_item()
1768 1769 1770
  {
    return new Item_decimal(name, &decimal_value, decimals, max_length);
  }
1771
  virtual void print(String *str, enum_query_type query_type);
1772 1773 1774 1775 1776 1777
  Item_num *neg()
  {
    my_decimal_neg(&decimal_value);
    unsigned_flag= !decimal_value.sign();
    return this;
  }
1778
  uint decimal_precision() const { return decimal_value.precision(); }
1779
  bool eq(const Item *, bool binary_cmp) const;
1780
  void set_decimal_value(my_decimal *value_par);
mikael@dator6.(none)'s avatar
mikael@dator6.(none) committed
1781
  bool check_partition_func_processor(uchar *bool_arg) { return FALSE;}
1782 1783
};

1784

1785
class Item_float :public Item_num
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1786
{
1787
  char *presentation;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1788
public:
1789
  double value;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1790
  // Item_real() :value(0) {}
1791 1792
  Item_float(const char *str_arg, uint length);
  Item_float(const char *str,double val_arg,uint decimal_par,uint length)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1793 1794
    :value(val_arg)
  {
1795
    presentation= name=(char*) str;
1796
    decimals=(uint8) decimal_par;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1797
    max_length=length;
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1798
    fixed= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1799
  }
1800 1801 1802 1803 1804
  Item_float(double value_par, uint decimal_par) :presentation(0), value(value_par)
  {
    decimals= (uint8) decimal_par;
    fixed= 1;
  }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1805
  int save_in_field(Field *field, bool no_conversions);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1806
  enum Type type() const { return REAL_ITEM; }
1807
  enum_field_types field_type() const { return MYSQL_TYPE_DOUBLE; }
1808
  double val_real() { DBUG_ASSERT(fixed == 1); return value; }
1809 1810 1811
  longlong val_int()
  {
    DBUG_ASSERT(fixed == 1);
1812 1813 1814 1815 1816 1817 1818 1819
    if (value <= (double) LONGLONG_MIN)
    {
       return LONGLONG_MIN;
    }
    else if (value >= (double) (ulonglong) LONGLONG_MAX)
    {
      return LONGLONG_MAX;
    }
1820
    return (longlong) rint(value);
1821
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1822
  String *val_str(String*);
1823
  my_decimal *val_decimal(my_decimal *);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1824
  bool basic_const_item() const { return 1; }
1825
  Item *clone_item()
1826
  { return new Item_float(name, value, decimals, max_length); }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1827
  Item_num *neg() { value= -value; return this; }
1828
  virtual void print(String *str, enum_query_type query_type);
1829
  bool eq(const Item *, bool binary_cmp) const;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1830 1831 1832
};


1833
class Item_static_float_func :public Item_float
1834 1835 1836
{
  const char *func_name;
public:
1837
  Item_static_float_func(const char *str, double val_arg, uint decimal_par,
1838
                        uint length)
1839
    :Item_float(NullS, val_arg, decimal_par, length), func_name(str)
1840
  {}
1841 1842 1843 1844 1845 1846

  virtual inline void print(String *str, enum_query_type query_type)
  {
    str->append(func_name);
  }

1847
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1848 1849 1850
};


1851
class Item_string :public Item_basic_constant
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1852 1853
{
public:
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1854
  Item_string(const char *str,uint length,
1855 1856
              CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE,
              uint repertoire= MY_REPERTOIRE_UNICODE30)
1857
    : m_cs_specified(FALSE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1858
  {
1859 1860
    str_value.set_or_copy_aligned(str, length, cs);
    collation.set(cs, dv, repertoire);
1861 1862 1863 1864
    /*
      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
1865
      number of chars for a string of this type because we in Create_field::
1866 1867
      divide the max_length with mbmaxlen).
    */
1868
    max_length= str_value.numchars()*cs->mbmaxlen;
bar@bar.mysql.r18.ru's avatar
bar@bar.mysql.r18.ru committed
1869
    set_name(str, length, cs);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1870
    decimals=NOT_FIXED_DEC;
1871 1872
    // it is constant => can be used without fix_fields (and frequently used)
    fixed= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1873
  }
1874 1875
  /* Just create an item and do not fill string representation */
  Item_string(CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE)
1876
    : m_cs_specified(FALSE)
1877 1878 1879 1880 1881 1882 1883
  {
    collation.set(cs, dv);
    max_length= 0;
    set_name(NULL, 0, cs);
    decimals= NOT_FIXED_DEC;
    fixed= 1;
  }
1884
  Item_string(const char *name_par, const char *str, uint length,
1885 1886
              CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE,
              uint repertoire= MY_REPERTOIRE_UNICODE30)
1887
    : m_cs_specified(FALSE)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1888
  {
1889 1890
    str_value.set_or_copy_aligned(str, length, cs);
    collation.set(cs, dv, repertoire);
1891
    max_length= str_value.numchars()*cs->mbmaxlen;
1892
    set_name(name_par, 0, cs);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1893
    decimals=NOT_FIXED_DEC;
1894 1895
    // it is constant => can be used without fix_fields (and frequently used)
    fixed= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1896
  }
1897 1898 1899 1900 1901 1902 1903 1904 1905
  /*
    This is used in stored procedures to avoid memory leaks and
    does a deep copy of its argument.
  */
  void set_str_with_copy(const char *str_arg, uint length_arg)
  {
    str_value.copy(str_arg, length_arg, collation.collation);
    max_length= str_value.numchars() * collation.collation->mbmaxlen;
  }
1906 1907 1908 1909 1910 1911
  void set_repertoire_from_value()
  {
    collation.repertoire= my_string_repertoire(str_value.charset(),
                                               str_value.ptr(),
                                               str_value.length());
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1912
  enum Type type() const { return STRING_ITEM; }
1913 1914
  double val_real();
  longlong val_int();
1915 1916 1917 1918 1919
  String *val_str(String*)
  {
    DBUG_ASSERT(fixed == 1);
    return (String*) &str_value;
  }
1920
  my_decimal *val_decimal(my_decimal *);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1921
  int save_in_field(Field *field, bool no_conversions);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1922
  enum Item_result result_type () const { return STRING_RESULT; }
1923
  enum_field_types field_type() const { return MYSQL_TYPE_VARCHAR; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1924
  bool basic_const_item() const { return 1; }
1925
  bool eq(const Item *item, bool binary_cmp) const;
1926
  Item *clone_item() 
1927
  {
1928
    return new Item_string(name, str_value.ptr(), 
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
1929
    			   str_value.length(), collation.collation);
1930
  }
bar@mysql.com's avatar
bar@mysql.com committed
1931
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1932 1933 1934 1935 1936
  inline void append(char *str, uint length)
  {
    str_value.append(str, length);
    max_length= str_value.numchars() * collation.collation->mbmaxlen;
  }
1937
  virtual void print(String *str, enum_query_type query_type);
1938
  bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980

  /**
    Return TRUE if character-set-introducer was explicitly specified in the
    original query for this item (text literal).

    This operation is to be called from Item_string::print(). The idea is
    that when a query is generated (re-constructed) from the Item-tree,
    character-set-introducers should appear only for those literals, where
    they were explicitly specified by the user. Otherwise, that may lead to
    loss collation information (character set introducers implies default
    collation for the literal).

    Basically, that makes sense only for views and hopefully will be gone
    one day when we start using original query as a view definition.

    @return This operation returns the value of m_cs_specified attribute.
      @retval TRUE if character set introducer was explicitly specified in
      the original query.
      @retval FALSE otherwise.
  */
  inline bool is_cs_specified() const
  {
    return m_cs_specified;
  }

  /**
    Set the value of m_cs_specified attribute.

    m_cs_specified attribute shows whether character-set-introducer was
    explicitly specified in the original query for this text literal or
    not. The attribute makes sense (is used) only for views.

    This operation is to be called from the parser during parsing an input
    query.
  */
  inline void set_cs_specified(bool cs_specified)
  {
    m_cs_specified= cs_specified;
  }

private:
  bool m_cs_specified;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1981 1982
};

1983 1984 1985 1986 1987 1988 1989 1990 1991 1992

class Item_static_string_func :public Item_string
{
  const char *func_name;
public:
  Item_static_string_func(const char *name_par, const char *str, uint length,
                          CHARSET_INFO *cs,
                          Derivation dv= DERIVATION_COERCIBLE)
    :Item_string(NullS, str, length, cs, dv), func_name(name_par)
  {}
1993
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1994 1995 1996 1997 1998 1999

  virtual inline void print(String *str, enum_query_type query_type)
  {
    str->append(func_name);
  }

2000
  bool check_partition_func_processor(uchar *int_arg) {return TRUE;}
2001 2002 2003
};


bk@work.mysql.com's avatar
bk@work.mysql.com committed
2004
/* for show tables */
2005
class Item_partition_func_safe_string: public Item_string
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2006 2007
{
public:
2008 2009 2010 2011
  Item_partition_func_safe_string(const char *name, uint length,
                                  CHARSET_INFO *cs= NULL):
    Item_string(name, length, cs)
  {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2012 2013
};

2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037

class Item_return_date_time :public Item_partition_func_safe_string
{
  enum_field_types date_time_field_type;
public:
  Item_return_date_time(const char *name_arg, enum_field_types field_type_arg)
    :Item_partition_func_safe_string(name_arg, 0, &my_charset_bin),
     date_time_field_type(field_type_arg)
  { }
  enum_field_types field_type() const { return date_time_field_type; }
};


class Item_blob :public Item_partition_func_safe_string
{
public:
  Item_blob(const char *name, uint length) :
    Item_partition_func_safe_string(name, length, &my_charset_bin)
  { max_length= length; }
  enum Type type() const { return TYPE_HOLDER; }
  enum_field_types field_type() const { return MYSQL_TYPE_BLOB; }
};


2038 2039 2040 2041 2042 2043
/**
  Item_empty_string -- is a utility class to put an item into List<Item>
  which is then used in protocol.send_fields() when sending SHOW output to
  the client.
*/

2044
class Item_empty_string :public Item_partition_func_safe_string
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2045 2046
{
public:
2047
  Item_empty_string(const char *header,uint length, CHARSET_INFO *cs= NULL) :
2048
    Item_partition_func_safe_string("",0, cs ? cs : &my_charset_utf8_general_ci)
2049
    { name=(char*) header; max_length= cs ? length * cs->mbmaxlen : length; }
2050
  void make_field(Send_field *field);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2051 2052
};

2053

2054 2055 2056 2057
class Item_return_int :public Item_int
{
  enum_field_types int_field_type;
public:
2058
  Item_return_int(const char *name_arg, uint length,
2059 2060
		  enum_field_types field_type_arg, longlong value= 0)
    :Item_int(name_arg, value, length), int_field_type(field_type_arg)
2061 2062 2063 2064 2065 2066 2067
  {
    unsigned_flag=1;
  }
  enum_field_types field_type() const { return int_field_type; }
};


2068
class Item_hex_string: public Item_basic_constant
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2069 2070
{
public:
2071
  Item_hex_string() {}
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
2072
  Item_hex_string(const char *str,uint str_length);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2073
  enum Type type() const { return VARBIN_ITEM; }
2074
  double val_real()
gkodinov/kgeorge@macbook.gmz's avatar
gkodinov/kgeorge@macbook.gmz committed
2075 2076 2077 2078
  { 
    DBUG_ASSERT(fixed == 1); 
    return (double) (ulonglong) Item_hex_string::val_int();
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2079
  longlong val_int();
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2080
  bool basic_const_item() const { return 1; }
2081
  String *val_str(String*) { DBUG_ASSERT(fixed == 1); return &str_value; }
2082
  my_decimal *val_decimal(my_decimal *);
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2083
  int save_in_field(Field *field, bool no_conversions);
2084
  enum Item_result result_type () const { return STRING_RESULT; }
2085
  enum Item_result cast_to_int_type() const { return INT_RESULT; }
2086
  enum_field_types field_type() const { return MYSQL_TYPE_VARCHAR; }
2087
  virtual void print(String *str, enum_query_type query_type);
2088
  bool eq(const Item *item, bool binary_cmp) const;
bar@mysql.com's avatar
bar@mysql.com committed
2089
  virtual Item *safe_charset_converter(CHARSET_INFO *tocs);
2090
  bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2091 2092 2093
};


ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
2094 2095 2096 2097 2098 2099
class Item_bin_string: public Item_hex_string
{
public:
  Item_bin_string(const char *str,uint str_length);
};

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2100 2101 2102 2103 2104
class Item_result_field :public Item	/* Item with result field */
{
public:
  Field *result_field;				/* Save result here */
  Item_result_field() :result_field(0) {}
2105
  // Constructor used for Item_sum/Item_cond_and/or (see Item comment)
2106 2107
  Item_result_field(THD *thd, Item_result_field *item):
    Item(thd, item), result_field(item->result_field)
2108
  {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2109
  ~Item_result_field() {}			/* Required with gcc 2.95 */
2110
  Field *get_tmp_table_field() { return result_field; }
2111
  Field *tmp_table_field(TABLE *t_arg) { return result_field; }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2112
  table_map used_tables() const { return 1; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2113
  virtual void fix_length_and_dec()=0;
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2114 2115 2116 2117 2118 2119
  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);
  }
2120
  void cleanup();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2121 2122 2123 2124 2125
};


class Item_ref :public Item_ident
{
2126 2127
protected:
  void set_properties();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2128
public:
2129
  enum Ref_Type { REF, DIRECT_REF, VIEW_REF, OUTER_REF };
hf@deer.(none)'s avatar
hf@deer.(none) committed
2130
  Field *result_field;			 /* Save result here */
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
2131
  Item **ref;
2132 2133 2134 2135 2136
  Item_ref(Name_resolution_context *context_arg,
           const char *db_arg, const char *table_name_arg,
           const char *field_name_arg)
    :Item_ident(context_arg, db_arg, table_name_arg, field_name_arg),
     result_field(0), ref(0) {}
2137
  /*
2138 2139 2140 2141 2142 2143 2144 2145 2146 2147
    This constructor is used in two scenarios:
    A) *item = NULL
      No initialization is performed, fix_fields() call will be necessary.
      
    B) *item points to an Item this Item_ref will refer to. This is 
      used for GROUP BY. fix_fields() will not be called in this case,
      so we call set_properties to make this item "fixed". set_properties
      performs a subset of action Item_ref::fix_fields does, and this subset
      is enough for Item_ref's used in GROUP BY.
    
2148 2149 2150
    TODO we probably fix a superset of problems like in BUG#6658. Check this 
         with Bar, and if we have a more broader set of problems like this.
  */
2151
  Item_ref(Name_resolution_context *context_arg, Item **item,
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
2152 2153
           const char *table_name_arg, const char *field_name_arg,
           bool alias_name_used_arg= FALSE);
2154

2155
  /* Constructor need to process subselect with temporary tables (see Item) */
2156 2157
  Item_ref(THD *thd, Item_ref *item)
    :Item_ident(thd, item), result_field(item->result_field), ref(item->ref) {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2158
  enum Type type() const		{ return REF_ITEM; }
2159
  bool eq(const Item *item, bool binary_cmp) const
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2160 2161 2162 2163
  { 
    Item *it= ((Item *) item)->real_item();
    return ref && (*ref)->eq(it, binary_cmp);
  }
2164 2165 2166 2167 2168 2169
  double val_real();
  longlong val_int();
  my_decimal *val_decimal(my_decimal *);
  bool val_bool();
  String *val_str(String* tmp);
  bool is_null();
2170
  bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
2171 2172 2173
  double val_result();
  longlong val_int_result();
  String *str_result(String* tmp);
2174 2175
  my_decimal *val_decimal_result(my_decimal *);
  bool val_bool_result();
2176
  bool send(Protocol *prot, String *tmp);
2177 2178
  void make_field(Send_field *field);
  bool fix_fields(THD *, Item **);
2179
  int save_in_field(Field *field, bool no_conversions);
2180
  void save_org_in_field(Field *field);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2181
  enum Item_result result_type () const { return (*ref)->result_type(); }
2182
  enum_field_types field_type() const   { return (*ref)->field_type(); }
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2183 2184
  Field *get_tmp_table_field()
  { return result_field ? result_field : (*ref)->get_tmp_table_field(); }
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
2185
  Item *get_tmp_table_item(THD *thd);
2186
  table_map used_tables() const		
2187
  {
2188 2189
    return depended_from ? OUTER_REF_TABLE_BIT : (*ref)->used_tables(); 
  }
gkodinov/kgeorge@macbook.local's avatar
gkodinov/kgeorge@macbook.local committed
2190 2191 2192 2193 2194
  void update_used_tables() 
  { 
    if (!depended_from) 
      (*ref)->update_used_tables(); 
  }
2195
  table_map not_null_tables() const { return (*ref)->not_null_tables(); }
2196
  void set_result_field(Field *field)	{ result_field= field; }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2197 2198 2199 2200 2201
  bool is_result_field() { return 1; }
  void save_in_result_field(bool no_conversions)
  {
    (*ref)->save_in_field(result_field, no_conversions);
  }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2202 2203
  Item *real_item()
  {
monty@mysql.com's avatar
monty@mysql.com committed
2204
    return ref ? (*ref)->real_item() : this;
2205
  }
2206
  bool walk(Item_processor processor, bool walk_subquery, uchar *arg)
2207
  { return (*ref)->walk(processor, walk_subquery, arg); }
2208
  virtual void print(String *str, enum_query_type query_type);
2209 2210 2211 2212
  bool result_as_longlong()
  {
    return (*ref)->result_as_longlong();
  }
monty@mysql.com's avatar
monty@mysql.com committed
2213
  void cleanup();
2214 2215
  Item_field *filed_for_view_update()
    { return (*ref)->filed_for_view_update(); }
2216
  virtual Ref_Type ref_type() { return REF; }
2217 2218 2219 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

  // Row emulation: forwarding of ROW-related calls to ref
  uint cols()
  {
    return ref && result_type() == ROW_RESULT ? (*ref)->cols() : 1;
  }
  Item* element_index(uint i)
  {
    return ref && result_type() == ROW_RESULT ? (*ref)->element_index(i) : this;
  }
  Item** addr(uint i)
  {
    return ref && result_type() == ROW_RESULT ? (*ref)->addr(i) : 0;
  }
  bool check_cols(uint c)
  {
    return ref && result_type() == ROW_RESULT ? (*ref)->check_cols(c) 
                                              : Item::check_cols(c);
  }
  bool null_inside()
  {
    return ref && result_type() == ROW_RESULT ? (*ref)->null_inside() : 0;
  }
  void bring_value()
  { 
    if (ref && result_type() == ROW_RESULT)
      (*ref)->bring_value();
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2246 2247
};

2248

2249 2250 2251 2252
/*
  The same as Item_ref, but get value from val_* family of method to get
  value of item on which it referred instead of result* family.
*/
2253 2254 2255
class Item_direct_ref :public Item_ref
{
public:
2256 2257
  Item_direct_ref(Name_resolution_context *context_arg, Item **item,
                  const char *table_name_arg,
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
2258 2259 2260 2261 2262
                  const char *field_name_arg,
                  bool alias_name_used_arg= FALSE)
    :Item_ref(context_arg, item, table_name_arg,
              field_name_arg, alias_name_used_arg)
  {}
2263 2264
  /* Constructor need to process subselect with temporary tables (see Item) */
  Item_direct_ref(THD *thd, Item_direct_ref *item) : Item_ref(thd, item) {}
2265

2266 2267 2268 2269 2270 2271
  double val_real();
  longlong val_int();
  String *val_str(String* tmp);
  my_decimal *val_decimal(my_decimal *);
  bool val_bool();
  bool is_null();
2272
  bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
2273
  virtual Ref_Type ref_type() { return DIRECT_REF; }
2274 2275
};

2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291
/*
  Class for view fields, the same as Item_direct_ref, but call fix_fields
  of reference if it is not called yet
*/
class Item_direct_view_ref :public Item_direct_ref
{
public:
  Item_direct_view_ref(Name_resolution_context *context_arg, Item **item,
                  const char *table_name_arg,
                  const char *field_name_arg)
    :Item_direct_ref(context_arg, item, table_name_arg, field_name_arg) {}
  /* Constructor need to process subselect with temporary tables (see Item) */
  Item_direct_view_ref(THD *thd, Item_direct_ref *item)
    :Item_direct_ref(thd, item) {}

  bool fix_fields(THD *, Item **);
2292
  bool eq(const Item *item, bool binary_cmp) const;
igor@olga.mysql.com's avatar
igor@olga.mysql.com committed
2293 2294 2295 2296 2297 2298
  Item *get_tmp_table_item(THD *thd)
  {
    Item *item= Item_ref::get_tmp_table_item(thd);
    item->name= name;
    return item;
  }
2299
  virtual Ref_Type ref_type() { return VIEW_REF; }
2300 2301
};

2302

2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313
/*
  Class for outer fields.
  An object of this class is created when the select where the outer field was
  resolved is a grouping one. After it has been fixed the ref field will point
  to either an Item_ref or an Item_direct_ref object which will be used to
  access the field.
  See also comments for the fix_inner_refs() and the
  Item_field::fix_outer_field() functions.
*/

class Item_sum;
2314 2315 2316
class Item_outer_ref :public Item_direct_ref
{
public:
2317 2318 2319 2320 2321 2322 2323 2324
  Item *outer_ref;
  /* The aggregate function under which this outer ref is used, if any. */
  Item_sum *in_sum_func;
  /*
    TRUE <=> that the outer_ref is already present in the select list
    of the outer select.
  */
  bool found_in_select_list;
2325 2326 2327
  Item_outer_ref(Name_resolution_context *context_arg,
                 Item_field *outer_field_arg)
    :Item_direct_ref(context_arg, 0, outer_field_arg->table_name,
2328 2329 2330
                     outer_field_arg->field_name),
    outer_ref(outer_field_arg), in_sum_func(0),
    found_in_select_list(0)
2331
  {
2332
    ref= &outer_ref;
2333 2334 2335
    set_properties();
    fixed= 0;
  }
2336 2337 2338 2339 2340 2341 2342
  Item_outer_ref(Name_resolution_context *context_arg, Item **item,
                 const char *table_name_arg, const char *field_name_arg,
                 bool alias_name_used_arg)
    :Item_direct_ref(context_arg, item, table_name_arg, field_name_arg,
                     alias_name_used_arg),
    outer_ref(0), in_sum_func(0), found_in_select_list(1)
  {}
2343 2344
  void save_in_result_field(bool no_conversions)
  {
2345
    outer_ref->save_org_in_field(result_field);
2346 2347 2348 2349 2350 2351 2352 2353 2354 2355
  }
  bool fix_fields(THD *, Item **);
  table_map used_tables() const
  {
    return (*ref)->const_item() ? 0 : OUTER_REF_TABLE_BIT;
  }
  virtual Ref_Type ref_type() { return OUTER_REF; }
};


2356
class Item_in_subselect;
2357

2358 2359 2360 2361 2362 2363 2364 2365 2366 2367

/*
  An object of this class:
   - Converts val_XXX() calls to ref->val_XXX_result() calls, like Item_ref.
   - Sets owner->was_null=TRUE if it has returned a NULL value from any
     val_XXX() function. This allows to inject an Item_ref_null_helper
     object into subquery and then check if the subquery has produced a row
     with NULL value.
*/

2368 2369 2370 2371 2372
class Item_ref_null_helper: public Item_ref
{
protected:
  Item_in_subselect* owner;
public:
2373 2374 2375 2376 2377
  Item_ref_null_helper(Name_resolution_context *context_arg,
                       Item_in_subselect* master, Item **item,
		       const char *table_name_arg, const char *field_name_arg)
    :Item_ref(context_arg, item, table_name_arg, field_name_arg),
     owner(master) {}
2378
  double val_real();
2379 2380
  longlong val_int();
  String* val_str(String* s);
2381 2382
  my_decimal *val_decimal(my_decimal *);
  bool val_bool();
2383
  bool get_date(MYSQL_TIME *ltime, uint fuzzydate);
2384
  virtual void print(String *str, enum_query_type query_type);
2385 2386 2387 2388 2389 2390 2391 2392 2393
  /*
    we add RAND_TABLE_BIT to prevent moving this item from HAVING to WHERE
  */
  table_map used_tables() const
  {
    return (depended_from ?
            OUTER_REF_TABLE_BIT :
            (*ref)->used_tables() | RAND_TABLE_BIT);
  }
2394 2395
};

2396
/*
2397
  The following class is used to optimize comparing of date and bigint columns
2398 2399 2400 2401 2402
  We need to save the original item ('ref') to be able to call
  ref->save_in_field(). This is used to create index search keys.
  
  An instance of Item_int_with_ref may have signed or unsigned integer value.
  
2403 2404 2405 2406 2407 2408
*/

class Item_int_with_ref :public Item_int
{
  Item *ref;
public:
2409 2410
  Item_int_with_ref(longlong i, Item *ref_arg, my_bool unsigned_arg) :
    Item_int(i), ref(ref_arg)
2411
  {
2412
    unsigned_flag= unsigned_arg;
2413
  }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
2414
  int save_in_field(Field *field, bool no_conversions)
2415
  {
2416
    return ref->save_in_field(field, no_conversions);
2417
  }
2418
  Item *clone_item();
2419
  virtual Item *real_item() { return ref; }
2420 2421
};

2422
#ifdef MYSQL_SERVER
2423
#include "gstream.h"
2424
#include "spatial.h"
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2425 2426
#include "item_sum.h"
#include "item_func.h"
2427
#include "item_row.h"
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2428 2429
#include "item_cmpfunc.h"
#include "item_strfunc.h"
2430
#include "item_geofunc.h"
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2431
#include "item_timefunc.h"
2432
#include "item_subselect.h"
2433
#include "item_xmlfunc.h"
2434
#endif
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2435 2436 2437

class Item_copy_string :public Item
{
2438
  enum enum_field_types cached_field_type;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2439 2440 2441 2442 2443 2444 2445 2446
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;
2447
    cached_field_type= item->field_type();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2448 2449 2450
  }
  enum Type type() const { return COPY_STR_ITEM; }
  enum Item_result result_type () const { return STRING_RESULT; }
2451
  enum_field_types field_type() const { return cached_field_type; }
2452
  double val_real()
2453
  {
monty@mysql.com's avatar
monty@mysql.com committed
2454 2455
    int err_not_used;
    char *end_not_used;
2456 2457
    return (null_value ? 0.0 :
	    my_strntod(str_value.charset(), (char*) str_value.ptr(),
monty@mysql.com's avatar
monty@mysql.com committed
2458
		       str_value.length(), &end_not_used, &err_not_used));
2459
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2460
  longlong val_int()
serg@serg.mylan's avatar
serg@serg.mylan committed
2461
  {
2462
    int err;
2463 2464 2465
    return null_value ? LL(0) : my_strntoll(str_value.charset(),str_value.ptr(),
                                            str_value.length(),10, (char**) 0,
                                            &err); 
2466
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2467
  String *val_str(String*);
2468
  my_decimal *val_decimal(my_decimal *);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2469 2470
  void make_field(Send_field *field) { item->make_field(field); }
  void copy();
2471 2472 2473 2474
  int save_in_field(Field *field, bool no_conversions)
  {
    return save_str_value_in_field(field, &str_value);
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2475 2476
  table_map used_tables() const { return (table_map) 1L; }
  bool const_item() const { return 0; }
2477
  bool is_null() { return null_value; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2478 2479 2480
};


serg@serg.mylan's avatar
serg@serg.mylan committed
2481
class Cached_item :public Sql_alloc
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2482 2483 2484
{
public:
  my_bool null_value;
serg@serg.mylan's avatar
serg@serg.mylan committed
2485
  Cached_item() :null_value(0) {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2486
  virtual bool cmp(void)=0;
serg@serg.mylan's avatar
serg@serg.mylan committed
2487
  virtual ~Cached_item(); /*line -e1509 */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2488 2489
};

serg@serg.mylan's avatar
serg@serg.mylan committed
2490
class Cached_item_str :public Cached_item
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2491 2492 2493 2494
{
  Item *item;
  String value,tmp_value;
public:
serg@serg.mylan's avatar
serg@serg.mylan committed
2495
  Cached_item_str(THD *thd, Item *arg);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2496
  bool cmp(void);
serg@serg.mylan's avatar
serg@serg.mylan committed
2497
  ~Cached_item_str();                           // Deallocate String:s
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2498 2499 2500
};


serg@serg.mylan's avatar
serg@serg.mylan committed
2501
class Cached_item_real :public Cached_item
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2502 2503 2504 2505
{
  Item *item;
  double value;
public:
serg@serg.mylan's avatar
serg@serg.mylan committed
2506
  Cached_item_real(Item *item_par) :item(item_par),value(0.0) {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2507 2508 2509
  bool cmp(void);
};

serg@serg.mylan's avatar
serg@serg.mylan committed
2510
class Cached_item_int :public Cached_item
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2511 2512 2513 2514
{
  Item *item;
  longlong value;
public:
serg@serg.mylan's avatar
serg@serg.mylan committed
2515
  Cached_item_int(Item *item_par) :item(item_par),value(0) {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2516 2517 2518 2519
  bool cmp(void);
};


serg@serg.mylan's avatar
serg@serg.mylan committed
2520
class Cached_item_decimal :public Cached_item
2521 2522 2523 2524
{
  Item *item;
  my_decimal value;
public:
serg@serg.mylan's avatar
serg@serg.mylan committed
2525
  Cached_item_decimal(Item *item_par);
2526 2527 2528
  bool cmp(void);
};

serg@serg.mylan's avatar
serg@serg.mylan committed
2529
class Cached_item_field :public Cached_item
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2530
{
2531
  uchar *buff;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2532 2533 2534 2535
  Field *field;
  uint length;

public:
serg@serg.mylan's avatar
serg@serg.mylan committed
2536
  Cached_item_field(Item_field *item)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2537
  {
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
2538
    field= item->field;
2539
    buff= (uchar*) sql_calloc(length=field->pack_length());
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2540 2541 2542 2543
  }
  bool cmp(void);
};

hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
2544 2545 2546 2547
class Item_default_value : public Item_field
{
public:
  Item *arg;
2548 2549 2550 2551 2552 2553 2554 2555
  Item_default_value(Name_resolution_context *context_arg)
    :Item_field(context_arg, (const char *)NULL, (const char *)NULL,
               (const char *)NULL),
     arg(NULL) {}
  Item_default_value(Name_resolution_context *context_arg, Item *a)
    :Item_field(context_arg, (const char *)NULL, (const char *)NULL,
                (const char *)NULL),
     arg(a) {}
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
2556
  enum Type type() const { return DEFAULT_VALUE_ITEM; }
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
2557
  bool eq(const Item *item, bool binary_cmp) const;
2558
  bool fix_fields(THD *, Item **);
2559
  virtual void print(String *str, enum_query_type query_type);
2560
  int save_in_field(Field *field_arg, bool no_conversions);
hf@deer.mysql.r18.ru's avatar
SCRUM  
hf@deer.mysql.r18.ru committed
2561
  table_map used_tables() const { return (table_map)0L; }
serg@serg.mylan's avatar
serg@serg.mylan committed
2562

2563
  bool walk(Item_processor processor, bool walk_subquery, uchar *args)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2564
  {
2565
    return arg->walk(processor, walk_subquery, args) ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2566 2567
      (this->*processor)(args);
  }
2568

2569
  Item *transform(Item_transformer transformer, uchar *args);
hf@deer.mysql.r18.ru's avatar
hf@deer.mysql.r18.ru committed
2570
};
hf@deer.mysql.r18.ru's avatar
hf@deer.mysql.r18.ru committed
2571

2572 2573 2574 2575 2576 2577 2578 2579 2580 2581
/*
  Item_insert_value -- an implementation of VALUES() function.
  You can use the VALUES(col_name) function in the UPDATE clause
  to refer to column values from the INSERT portion of the INSERT
  ... UPDATE statement. In other words, VALUES(col_name) in the
  UPDATE clause refers to the value of col_name that would be
  inserted, had no duplicate-key conflict occurred.
  In all other places this function returns NULL.
*/

2582 2583 2584 2585
class Item_insert_value : public Item_field
{
public:
  Item *arg;
2586 2587 2588 2589
  Item_insert_value(Name_resolution_context *context_arg, Item *a)
    :Item_field(context_arg, (const char *)NULL, (const char *)NULL,
               (const char *)NULL),
     arg(a) {}
2590
  bool eq(const Item *item, bool binary_cmp) const;
2591
  bool fix_fields(THD *, Item **);
2592
  virtual void print(String *str, enum_query_type query_type);
2593
  int save_in_field(Field *field_arg, bool no_conversions)
2594
  {
2595
    return Item_field::save_in_field(field_arg, no_conversions);
2596
  }
2597 2598 2599 2600 2601
  /* 
   We use RAND_TABLE_BIT to prevent Item_insert_value from
   being treated as a constant and precalculated before execution
  */
  table_map used_tables() const { return RAND_TABLE_BIT; }
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2602

2603
  bool walk(Item_processor processor, bool walk_subquery, uchar *args)
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2604
  {
2605
    return arg->walk(processor, walk_subquery, args) ||
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2606 2607
	    (this->*processor)(args);
  }
2608 2609
};

2610 2611 2612 2613 2614 2615 2616 2617 2618 2619

/*
  We need this two enums here instead of sql_lex.h because
  at least one of them is used by Item_trigger_field interface.

  Time when trigger is invoked (i.e. before or after row actually
  inserted/updated/deleted).
*/
enum trg_action_time_type
{
2620
  TRG_ACTION_BEFORE= 0, TRG_ACTION_AFTER= 1, TRG_ACTION_MAX
2621 2622
};

2623 2624
class Table_triggers_list;

2625 2626 2627 2628
/*
  Represents NEW/OLD version of field of row which is
  changed/read in trigger.

2629 2630 2631 2632 2633 2634
  Note: For this item main part of actual binding to Field object happens
        not during fix_fields() call (like for Item_field) but right after
        parsing of trigger definition, when table is opened, with special
        setup_field() call. On fix_fields() stage we simply choose one of
        two Field instances representing either OLD or NEW version of this
        field.
2635
*/
2636 2637
class Item_trigger_field : public Item_field,
                           private Settable_routine_parameter
2638 2639 2640 2641 2642
{
public:
  /* Is this item represents row from NEW or OLD row ? */
  enum row_version_type {OLD_ROW, NEW_ROW};
  row_version_type row_version;
2643 2644
  /* Next in list of all Item_trigger_field's in trigger */
  Item_trigger_field *next_trg_field;
2645 2646 2647 2648
  /* Index of the field in the TABLE::field array */
  uint field_idx;
  /* Pointer to Table_trigger_list object for table of this trigger */
  Table_triggers_list *triggers;
2649

2650 2651
  Item_trigger_field(Name_resolution_context *context_arg,
                     row_version_type row_ver_arg,
2652
                     const char *field_name_arg,
2653
                     ulong priv, const bool ro)
2654 2655
    :Item_field(context_arg,
               (const char *)NULL, (const char *)NULL, field_name_arg),
2656 2657
     row_version(row_ver_arg), field_idx((uint)-1), original_privilege(priv),
     want_privilege(priv), table_grants(NULL), read_only (ro)
2658
  {}
2659
  void setup_field(THD *thd, TABLE *table, GRANT_INFO *table_grant_info);
2660 2661
  enum Type type() const { return TRIGGER_FIELD_ITEM; }
  bool eq(const Item *item, bool binary_cmp) const;
2662
  bool fix_fields(THD *, Item **);
2663
  virtual void print(String *str, enum_query_type query_type);
2664
  table_map used_tables() const { return (table_map)0L; }
2665 2666 2667
  Field *get_tmp_table_field() { return 0; }
  Item *copy_or_same(THD *thd) { return this; }
  Item *get_tmp_table_item(THD *thd) { return copy_or_same(thd); }
2668
  void cleanup();
2669 2670

private:
2671
  void set_required_privilege(bool rw);
2672
  bool set_value(THD *thd, sp_rcontext *ctx, Item **it);
2673 2674 2675 2676 2677 2678 2679

public:
  Settable_routine_parameter *get_settable_routine_parameter()
  {
    return (read_only ? 0 : this);
  }

2680
  bool set_value(THD *thd, Item **it)
2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697
  {
    return set_value(thd, NULL, it);
  }

private:
  /*
    'want_privilege' holds privileges required to perform operation on
    this trigger field (SELECT_ACL if we are going to read it and
    UPDATE_ACL if we are going to update it).  It is initialized at
    parse time but can be updated later if this trigger field is used
    as OUT or INOUT parameter of stored routine (in this case
    set_required_privilege() is called to appropriately update
    want_privilege and cleanup() is responsible for restoring of
    original want_privilege once parameter's value is updated).
  */
  ulong original_privilege;
  ulong want_privilege;
2698
  GRANT_INFO *table_grants;
2699 2700 2701 2702 2703
  /*
    Trigger field is read-only unless it belongs to the NEW row in a
    BEFORE INSERT of BEFORE UPDATE trigger.
  */
  bool read_only;
2704 2705 2706
};


2707
class Item_cache: public Item_basic_constant
2708
{
2709 2710
protected:
  Item *example;
2711
  table_map used_table_map;
2712 2713 2714 2715 2716 2717 2718
  /*
    Field that this object will get value from. This is set/used by 
    index-based subquery engines to detect and remove the equality injected 
    by IN->EXISTS transformation.
    For all other uses of Item_cache, cached_field doesn't matter.
  */  
  Field *cached_field;
2719
  enum enum_field_types cached_field_type;
2720
public:
2721
  Item_cache(): 
2722
    example(0), used_table_map(0), cached_field(0), cached_field_type(MYSQL_TYPE_STRING) 
2723 2724 2725 2726 2727
  {
    fixed= 1; 
    null_value= 1;
  }
  Item_cache(enum_field_types field_type_arg):
2728
    example(0), used_table_map(0), cached_field(0), cached_field_type(field_type_arg)
2729 2730 2731 2732
  {
    fixed= 1;
    null_value= 1;
  }
2733 2734 2735

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

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2736
  virtual bool allocate(uint i) { return 0; }
2737
  virtual bool setup(Item *item)
2738
  {
2739 2740 2741 2742
    example= item;
    max_length= item->max_length;
    decimals= item->decimals;
    collation.set(item->collation);
2743
    unsigned_flag= item->unsigned_flag;
2744 2745
    if (item->type() == FIELD_ITEM)
      cached_field= ((Item_field *)item)->field;
2746 2747
    return 0;
  };
2748 2749
  virtual void store(Item *)= 0;
  enum Type type() const { return CACHE_ITEM; }
2750
  enum_field_types field_type() const { return cached_field_type; }
2751
  static Item_cache* get_cache(const Item *item);
2752
  table_map used_tables() const { return used_table_map; }
2753
  virtual void keep_array() {}
2754
  virtual void print(String *str, enum_query_type query_type);
2755 2756 2757 2758 2759 2760 2761 2762
  bool eq_def(Field *field) 
  { 
    return cached_field ? cached_field->eq_def (field) : FALSE;
  }
  bool eq(const Item *item, bool binary_cmp) const
  {
    return this == item;
  }
2763 2764
};

2765

2766 2767
class Item_cache_int: public Item_cache
{
2768
protected:
2769 2770
  longlong value;
public:
2771
  Item_cache_int(): Item_cache(), value(0) {}
2772 2773
  Item_cache_int(enum_field_types field_type_arg):
    Item_cache(field_type_arg), value(0) {}
2774

2775
  void store(Item *item);
2776
  void store(Item *item, longlong val_arg);
2777
  double val_real() { DBUG_ASSERT(fixed == 1); return (double) value; }
2778
  longlong val_int() { DBUG_ASSERT(fixed == 1); return value; }
2779 2780
  String* val_str(String *str);
  my_decimal *val_decimal(my_decimal *);
2781
  enum Item_result result_type() const { return INT_RESULT; }
2782
  bool result_as_longlong() { return TRUE; }
2783 2784
};

2785

2786 2787 2788 2789
class Item_cache_real: public Item_cache
{
  double value;
public:
2790
  Item_cache_real(): Item_cache(), value(0) {}
2791

2792
  void store(Item *item);
2793
  double val_real() { DBUG_ASSERT(fixed == 1); return value; }
2794 2795 2796
  longlong val_int();
  String* val_str(String *str);
  my_decimal *val_decimal(my_decimal *);
2797 2798 2799
  enum Item_result result_type() const { return REAL_RESULT; }
};

2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816

class Item_cache_decimal: public Item_cache
{
protected:
  my_decimal decimal_value;
public:
  Item_cache_decimal(): Item_cache() {}

  void store(Item *item);
  double val_real();
  longlong val_int();
  String* val_str(String *str);
  my_decimal *val_decimal(my_decimal *);
  enum Item_result result_type() const { return DECIMAL_RESULT; }
};


2817 2818
class Item_cache_str: public Item_cache
{
2819
  char buffer[STRING_BUFFER_USUAL_SIZE];
2820
  String *value, value_buff;
2821 2822
  bool is_varbinary;
  
2823
public:
2824 2825 2826 2827 2828 2829 2830
  Item_cache_str(const Item *item) :
    Item_cache(), value(0),
    is_varbinary(item->type() == FIELD_ITEM &&
                 ((const Item_field *) item)->field->type() ==
                   MYSQL_TYPE_VARCHAR &&
                 !((const Item_field *) item)->field->has_charset())
  {}
2831
  void store(Item *item);
2832
  double val_real();
2833
  longlong val_int();
2834
  String* val_str(String *) { DBUG_ASSERT(fixed == 1); return value; }
2835
  my_decimal *val_decimal(my_decimal *);
2836 2837
  enum Item_result result_type() const { return STRING_RESULT; }
  CHARSET_INFO *charset() const { return value->charset(); };
2838
  int save_in_field(Field *field, bool no_conversions);
2839 2840
};

2841 2842 2843
class Item_cache_row: public Item_cache
{
  Item_cache  **values;
2844
  uint item_count;
2845
  bool save_array;
2846
public:
2847 2848
  Item_cache_row()
    :Item_cache(), values(0), item_count(2), save_array(0) {}
2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865
  
  /*
    '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");
  };
2866
  double val_real()
2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880
  {
    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;
  };
2881 2882 2883 2884 2885 2886
  my_decimal *val_decimal(my_decimal *val)
  {
    illegal_method_call((const char*)"val_decimal");
    return 0;
  };

2887 2888
  enum Item_result result_type() const { return ROW_RESULT; }
  
2889
  uint cols() { return item_count; }
2890 2891
  Item *element_index(uint i) { return values[i]; }
  Item **addr(uint i) { return (Item **) (values + i); }
2892 2893 2894
  bool check_cols(uint c);
  bool null_inside();
  void bring_value();
2895
  void keep_array() { save_array= 1; }
hf@deer.(none)'s avatar
hf@deer.(none) committed
2896 2897
  void cleanup()
  {
2898
    DBUG_ENTER("Item_cache_row::cleanup");
hf@deer.(none)'s avatar
hf@deer.(none) committed
2899
    Item_cache::cleanup();
2900 2901 2902 2903
    if (save_array)
      bzero(values, item_count*sizeof(Item**));
    else
      values= 0;
2904
    DBUG_VOID_RETURN;
hf@deer.(none)'s avatar
hf@deer.(none) committed
2905
  }
2906 2907
};

2908 2909

/*
2910 2911 2912 2913 2914
  Item_type_holder used to store type. name, length of Item for UNIONS &
  derived tables.

  Item_type_holder do not need cleanup() because its time of live limited by
  single SP/PS execution.
2915 2916 2917 2918
*/
class Item_type_holder: public Item
{
protected:
2919 2920
  TYPELIB *enum_set_typelib;
  enum_field_types fld_type;
2921
  Field::geometry_type geometry_type;
2922 2923

  void get_full_info(Item *item);
2924 2925 2926

  /* It is used to count decimal precision in join_types */
  int prev_decimal_int_part;
2927
public:
2928
  Item_type_holder(THD*, Item*);
2929

2930
  Item_result result_type() const;
2931
  enum_field_types field_type() const { return fld_type; };
2932
  enum Type type() const { return TYPE_HOLDER; }
2933
  double val_real();
2934
  longlong val_int();
2935
  my_decimal *val_decimal(my_decimal *);
2936
  String *val_str(String*);
2937 2938 2939 2940
  bool join_types(THD *thd, Item *);
  Field *make_field_by_type(TABLE *table);
  static uint32 display_length(Item *item);
  static enum_field_types get_real_type(Item *);
2941
  Field::geometry_type get_geometry_type() const { return geometry_type; };
2942 2943
};

2944

2945 2946 2947
class st_select_lex;
void mark_select_range_as_dependent(THD *thd,
                                    st_select_lex *last_select,
bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
2948
                                    st_select_lex *current_sel,
2949 2950
                                    Field *found_field, Item *found_item,
                                    Item_ident *resolved_item);
2951

serg@serg.mylan's avatar
serg@serg.mylan committed
2952
extern Cached_item *new_Cached_item(THD *thd, Item *item);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2953
extern Item_result item_cmp_type(Item_result a,Item_result b);
2954
extern void resolve_const_item(THD *thd, Item **ref, Item *cmp_item);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2955
extern bool field_is_equal_to_item(Field *field,Item *item);