item.h 104 KB
Newer Older
1
/* Copyright (c) 2000, 2010 Oracle and/or its affiliates. All rights reserved.
unknown's avatar
unknown committed
2

unknown's avatar
unknown 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
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
unknown's avatar
unknown committed
6

unknown's avatar
unknown 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.
unknown's avatar
unknown committed
11

unknown's avatar
unknown 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
unknown's avatar
unknown committed
18 19 20
#pragma interface			/* gcc class implementation */
#endif

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

26 27
/*
   "Declared Type Collation"
unknown's avatar
unknown committed
28
   A combination of collation and its derivation.
29

30
  Flags for collation aggregation modes:
unknown's avatar
unknown 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
unknown's avatar
unknown committed
35
                                 (combination of the above two)
unknown's avatar
unknown 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
unknown's avatar
unknown 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;
unknown's avatar
unknown committed
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;
unknown's avatar
unknown committed
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)
  {
unknown's avatar
unknown committed
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
};

unknown's avatar
unknown committed
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

  The NOT_NULL enums are used in TO_DAYS, since TO_DAYS('2001-00-00') returns
  NULL which puts those rows into the NULL partition, but
  '2000-12-31' < '2001-00-00' < '2001-01-01'. So special handling is needed
  for this (see Bug#20577).
unknown's avatar
unknown committed
405 406 407 408 409
*/

typedef enum monotonicity_info 
{
   NON_MONOTONIC,              /* none of the below holds */
410
   MONOTONIC_INCREASING,       /* F() is unary and (x < y) => (F(x) <= F(y)) */
411 412 413
   MONOTONIC_INCREASING_NOT_NULL,  /* But only for valid/real x and y */
   MONOTONIC_STRICT_INCREASING,/* F() is unary and (x < y) => (F(x) <  F(y)) */
   MONOTONIC_STRICT_INCREASING_NOT_NULL  /* But only for valid/real x and y */
unknown's avatar
unknown committed
414 415
} enum_monotonicity_info;

416 417
/*************************************************************************/

418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
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.
  */
434 435
  Settable_routine_parameter() {}
  virtual ~Settable_routine_parameter() {}
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
  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.
  */
452
  virtual bool set_value(THD *thd, sp_rcontext *ctx, Item **it)= 0;
453 454 455
};


456
typedef bool (Item::*Item_processor) (uchar *arg);
457 458 459 460 461 462 463 464 465 466 467
/*
  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

*/
468 469
typedef bool (Item::*Item_analyzer) (uchar **argp);
typedef Item* (Item::*Item_transformer) (uchar *arg);
470
typedef void (*Cond_traverser) (const Item *item, void *arg);
471

472

unknown's avatar
unknown committed
473
class Item {
unknown's avatar
unknown committed
474
  Item(const Item &);			/* Prevent use of these */
unknown's avatar
unknown committed
475 476
  void operator=(Item &);
public:
477
  static void *operator new(size_t size) throw ()
478
  { return sql_alloc(size); }
479
  static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
480
  { return alloc_root(mem_root, size); }
unknown's avatar
unknown committed
481
  static void operator delete(void *ptr,size_t size) { TRASH(ptr, size); }
482
  static void operator delete(void *ptr, MEM_ROOT *mem_root) {}
unknown's avatar
unknown committed
483

484
  enum Type {FIELD_ITEM= 0, FUNC_ITEM, SUM_FUNC_ITEM, STRING_ITEM,
485
	     INT_ITEM, REAL_ITEM, NULL_ITEM, VARBIN_ITEM,
unknown's avatar
SCRUM  
unknown committed
486
	     COPY_STR_ITEM, FIELD_AVG_ITEM, DEFAULT_VALUE_ITEM,
unknown's avatar
unknown committed
487 488
	     PROC_ITEM,COND_ITEM, REF_ITEM, FIELD_STD_ITEM,
	     FIELD_VARIANCE_ITEM, INSERT_VALUE_ITEM,
489
             SUBSELECT_ITEM, ROW_ITEM, CACHE_ITEM, TYPE_HOLDER,
490
             PARAM_ITEM, TRIGGER_FIELD_ITEM, DECIMAL_ITEM,
491
             XPATH_NODESET, XPATH_NODESET_CMP,
492
             VIEW_FIXER_ITEM};
unknown's avatar
SCRUM  
unknown committed
493

unknown's avatar
unknown committed
494
  enum cond_result { COND_UNDEF,COND_OK,COND_TRUE,COND_FALSE };
495 496

  enum traverse_order { POSTFIX, PREFIX };
497
  
498 499 500
  /* Reuse size, only used by SP local variable assignment, otherwize 0 */
  uint rsize;

unknown's avatar
unknown committed
501 502 503 504 505
  /*
    str_values's main purpose is to be used to cache the value in
    save_in_field
  */
  String str_value;
506
  char * name;			/* Name from select */
507
  /* Original item name (if it was renamed)*/
508
  char * orig_name;
509 510 511 512 513 514 515
  /**
     Intrusive list pointer for free list. If not null, points to the next
     Item on some Query_arena's free list. For instance, stored procedures
     have their own Query_arena's.

     @see Query_arena::free_list
   */
unknown's avatar
unknown committed
516 517
  Item *next;
  uint32 max_length;
518
  uint name_length;                     /* Length of name */
519 520
  int8 marker;
  uint8 decimals;
unknown's avatar
unknown committed
521 522
  my_bool maybe_null;			/* If item may be null */
  my_bool null_value;			/* if item is null */
523
  my_bool unsigned_flag;
unknown's avatar
unknown committed
524
  my_bool with_sum_func;
525
  my_bool fixed;                        /* If item fixed with fix_fields */
526 527
  my_bool is_autogenerated_name;        /* indicate was name of this Item
                                           autogenerated or set by user */
528
  DTCollation collation;
529 530 531
  my_bool with_subselect;               /* If this item is a subselect or some
                                           of its arguments is or contains a
                                           subselect */
532
  Item_result cmp_context;              /* Comparison context */
unknown's avatar
unknown committed
533 534
  // alloc & destruct is done as start of select using sql_alloc
  Item();
535
  /*
unknown's avatar
unknown committed
536
     Constructor used by Item_field, Item_ref & aggregate (sum) functions.
537 538
     Used for duplicating lists in processing queries with temporary
     tables
539
     Also it used for Item_cond_and/Item_cond_or for creating
unknown's avatar
unknown committed
540
     top AND/OR structure of WHERE clause to protect it of
541
     optimisation changes in prepared statements
542
  */
543
  Item(THD *thd, Item *item);
unknown's avatar
unknown committed
544 545
  virtual ~Item()
  {
unknown's avatar
unknown committed
546
#ifdef EXTRA_DEBUG
unknown's avatar
unknown committed
547
    name=0;
unknown's avatar
unknown committed
548
#endif
unknown's avatar
unknown committed
549
  }		/*lint -e1509 */
550
  void set_name(const char *str, uint length, CHARSET_INFO *cs);
551
  void rename(char *new_name);
unknown's avatar
unknown committed
552
  void init_make_field(Send_field *tmp_field,enum enum_field_types type);
553
  virtual void cleanup();
554
  virtual void make_field(Send_field *field);
555
  Field *make_string_field(TABLE *table);
556
  virtual bool fix_fields(THD *, Item **);
unknown's avatar
unknown committed
557
  /*
unknown's avatar
unknown committed
558
    should be used in case where we are sure that we do not need
unknown's avatar
unknown committed
559 560 561
    complete fix_fields() procedure.
  */
  inline void quick_fix_field() { fixed= 1; }
unknown's avatar
unknown committed
562
  /* Function returns 1 on overflow and -1 on fatal errors */
563
  int save_in_field_no_warnings(Field *field, bool no_conversions);
unknown's avatar
unknown committed
564
  virtual int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
565
  virtual void save_org_in_field(Field *field)
566
  { (void) save_in_field(field, 1); }
unknown's avatar
unknown committed
567
  virtual int save_safe_in_field(Field *field)
568
  { return save_in_field(field, 1); }
569
  virtual bool send(Protocol *protocol, String *str);
570
  virtual bool eq(const Item *, bool binary_cmp) const;
Sergei Golubchik's avatar
Sergei Golubchik committed
571
  /* result_type() of an item specifies how the value should be returned */
572
  virtual Item_result result_type() const { return REAL_RESULT; }
Sergei Golubchik's avatar
Sergei Golubchik committed
573
  /* ... while cmp_type() specifies how it should be compared */
574 575
  virtual Item_result cmp_type() const;
  virtual Item_result cast_to_int_type() const { return cmp_type(); }
576
  virtual enum_field_types string_field_type() const;
577
  virtual enum_field_types field_type() const;
unknown's avatar
unknown committed
578
  virtual enum Type type() const =0;
unknown's avatar
unknown committed
579 580 581 582 583 584 585 586 587
  
  /*
    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; }

588 589 590 591 592 593 594 595
  /*
    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"

596 597
        incl_endp  IN   FALSE <=> the comparison is '<' or '>'
                        TRUE  <=> the comparison is '<=' or '>='
598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
                   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)
unknown's avatar
unknown committed
622
  { DBUG_ASSERT(0); return 0; }
623 624


625
  /* valXXX methods must return NULL or 0 or 0.0 if null_value is set. */
unknown's avatar
unknown committed
626 627 628 629 630 631 632 633 634 635
  /*
    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.
  */
636
  virtual double val_real()=0;
unknown's avatar
unknown committed
637 638 639 640 641 642 643 644 645 646
  /*
    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.
  */
unknown's avatar
unknown committed
647
  virtual longlong val_int()=0;
648 649 650 651 652
  /*
    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(); }
653 654 655
  /*
    Return string representation of this item object.

unknown's avatar
unknown committed
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 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712
    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)
713
  */
unknown's avatar
unknown committed
714
  virtual bool val_bool();
715
  virtual String *val_nodeset(String*) { return 0; }
716 717 718 719 720 721 722
  /* 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);
723 724
  my_decimal *val_decimal_from_date(my_decimal *decimal_value);
  my_decimal *val_decimal_from_time(my_decimal *decimal_value);
725 726 727
  longlong val_int_from_decimal();
  double val_real_from_decimal();

728 729
  int save_time_in_field(Field *field);
  int save_date_in_field(Field *field);
730
  int save_str_value_in_field(Field *field, String *result);
731

732
  virtual Field *get_tmp_table_field() { return 0; }
unknown's avatar
unknown committed
733
  /* This is also used to create fields in CREATE ... SELECT: */
734
  virtual Field *tmp_table_field(TABLE *t_arg) { return 0; }
unknown's avatar
unknown committed
735
  virtual const char *full_name() const { return name ? name : "???"; }
Sergei Golubchik's avatar
Sergei Golubchik committed
736 737
  const char *field_name_or_null()
  { return real_item()->type() == Item::FIELD_ITEM ? name : NULL; }
unknown's avatar
unknown committed
738 739 740 741 742 743 744

  /*
    *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.
  */
745
  virtual double  val_result() { return val_real(); }
unknown's avatar
unknown committed
746 747
  virtual longlong val_int_result() { return val_int(); }
  virtual String *str_result(String* tmp) { return val_str(tmp); }
unknown's avatar
unknown committed
748 749 750
  virtual my_decimal *val_decimal_result(my_decimal *val)
  { return val_decimal(val); }
  virtual bool val_bool_result() { return val_bool(); }
751
  virtual bool is_null_result() { return is_null(); }
unknown's avatar
unknown committed
752

753
  /* bit map of tables used by item */
unknown's avatar
unknown committed
754
  virtual table_map used_tables() const { return (table_map) 0L; }
755 756 757 758 759 760 761 762 763 764 765 766 767 768
  /*
    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
769
    a constant expression. Used in the optimizer to propagate basic constants.
770
  */
unknown's avatar
unknown committed
771
  virtual bool basic_const_item() const { return 0; }
unknown's avatar
unknown committed
772
  /* cloning of constant items (0 if it is not const) */
773
  virtual Item *clone_item() { return 0; }
unknown's avatar
unknown committed
774 775 776
  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;}
unknown's avatar
unknown committed
777 778
  virtual uint decimal_precision() const;
  inline int decimal_int_part() const
779
  { return my_decimal_int_part(decimal_precision(), decimals); }
780 781 782 783
  /* 
    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.
  */
unknown's avatar
unknown committed
784
  virtual bool const_item() const { return used_tables() == 0; }
785 786 787 788 789 790
  /* 
    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; }
791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808

  /**
    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);
809
  void print_value(String *);
unknown's avatar
unknown committed
810
  virtual void update_used_tables() {}
811 812
  virtual void split_sum_func(THD *thd, Item **ref_pointer_array,
                              List<Item> &fields) {}
813 814
  /* Called for items that really have to be split */
  void split_sum_func2(THD *thd, Item **ref_pointer_array, List<Item> &fields,
unknown's avatar
unknown committed
815
                       Item **ref, bool skip_registered);
816
  virtual bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
817
  bool get_time(MYSQL_TIME *ltime);
818
  virtual bool get_date_result(MYSQL_TIME *ltime,uint fuzzydate)
819
  { return get_date(ltime,fuzzydate); }
820
  /*
821 822 823 824 825
    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.
826
  */
827
  virtual bool is_null() { return 0; }
828

829 830 831 832 833
  /*
   Make sure the null_value member has a correct value.
  */
  virtual void update_null_value () { (void) val_int(); }

unknown's avatar
unknown committed
834
  /*
835 836 837 838 839 840 841 842
    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".
unknown's avatar
unknown committed
843
  */
844
  virtual void top_level_item() {}
unknown's avatar
unknown committed
845 846
  /*
    set field of temporary table for Item which can be switched on temporary
unknown's avatar
unknown committed
847
    table during query processing (grouping and so on)
unknown's avatar
unknown committed
848
  */
unknown's avatar
unknown committed
849 850
  virtual void set_result_field(Field *field) {}
  virtual bool is_result_field() { return 0; }
unknown's avatar
unknown committed
851
  virtual bool is_bool_func() { return 0; }
unknown's avatar
unknown committed
852
  virtual void save_in_result_field(bool no_conversions) {}
unknown's avatar
unknown committed
853
  /*
unknown's avatar
unknown committed
854
    set value of aggregate function in case of no rows for grouping were found
unknown's avatar
unknown committed
855
  */
unknown's avatar
unknown committed
856
  virtual void no_rows_in_result() {}
857
  virtual Item *copy_or_same(THD *thd) { return this; }
858
  virtual Item *copy_andor_structure(THD *thd) { return this; }
unknown's avatar
unknown committed
859
  virtual Item *real_item() { return this; }
860
  virtual Item *get_tmp_table_item(THD *thd) { return copy_or_same(thd); }
unknown's avatar
unknown committed
861

862
  static CHARSET_INFO *default_charset();
863
  virtual CHARSET_INFO *compare_collation() { return NULL; }
unknown's avatar
unknown committed
864

865
  virtual bool walk(Item_processor processor, bool walk_subquery, uchar *arg)
unknown's avatar
unknown committed
866 867 868 869
  {
    return (this->*processor)(arg);
  }

870
  virtual Item* transform(Item_transformer transformer, uchar *arg);
871

872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887
  /*
    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.      
  */
888 889
  virtual Item* compile(Item_analyzer analyzer, uchar **arg_p,
                        Item_transformer transformer, uchar *arg_t)
890 891 892 893 894 895
  {
    if ((this->*analyzer) (arg_p))
      return ((this->*transformer) (arg_t));
    return 0;
  }

896 897
   virtual void traverse_cond(Cond_traverser traverser,
                              void *arg, traverse_order order)
898 899 900
   {
     (*traverser)(this, arg);
   }
901

902 903 904 905 906 907 908 909
  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; }
910
  virtual bool find_item_processor(uchar *arg) { return this == (void *) arg; }
911
  virtual bool register_field_in_read_map(uchar *arg) { return 0; }
912
  /*
913 914 915
    Check if a partition function is allowed
    SYNOPSIS
      check_partition_func_processor()
916
      int_arg                        Ignored
917
    RETURN VALUE
918 919 920
      TRUE                           Partition function not accepted
      FALSE                          Partition function accepted

921
    DESCRIPTION
922
    check_partition_func_processor is used to check if a partition function
923 924 925 926 927 928 929
    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
unknown's avatar
unknown committed
930
    in a partition function. Allowed functions
931 932 933 934 935 936 937 938
    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.
unknown's avatar
unknown committed
939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961

    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.
962
  */
963 964
  virtual bool check_partition_func_processor(uchar *bool_arg) { return TRUE;}
  virtual bool subst_argument_checker(uchar **arg)
965 966 967 968 969
  { 
    if (*arg)
      *arg= NULL; 
    return TRUE;     
  }
970

971 972 973
  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; }
974 975 976 977 978 979 980 981 982
  /*
    Check if an expression value depends on the current timezone. Used by
    partitioning code to reject timezone-dependent expressions in a
    (sub)partitioning function.
  */
  virtual bool is_timezone_dependent_processor(uchar *bool_arg)
  {
    return FALSE;
  }
983

984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000
  /**
    Find a function of a given type

    @param   arg     the function type to search (enum Item_func::Functype)
    @return
      @retval TRUE   the function type we're searching for is found
      @retval FALSE  the function type wasn't found

    @description
      This function can be used (together with Item::walk()) to find functions
      in an item tree fragment.
  */
  virtual bool find_function_processor (uchar *arg)
  {
    return FALSE;
  }

1001 1002 1003 1004 1005
  /*
    For SP local variable returns pointer to Item representing its
    current value and pointer to current Item otherwise.
  */
  virtual Item *this_item() { return this; }
1006 1007
  virtual const Item *this_item() const { return this; }

1008 1009 1010 1011
  /*
    For SP local variable returns address of pointer to Item representing its
    current value and pointer passed via parameter otherwise.
  */
1012
  virtual Item **this_item_addr(THD *thd, Item **addr_arg) { return addr_arg; }
unknown's avatar
unknown committed
1013 1014 1015

  // Row emulation
  virtual uint cols() { return 1; }
1016
  virtual Item* element_index(uint i) { return this; }
1017
  virtual Item** addr(uint i) { return 0; }
unknown's avatar
unknown committed
1018
  virtual bool check_cols(uint c);
unknown's avatar
unknown committed
1019
  // It is not row => null inside is impossible
1020 1021 1022
  virtual bool null_inside() { return 0; }
  // used in row subselects to get value of elements
  virtual void bring_value() {}
1023

unknown's avatar
unknown committed
1024
  Field *tmp_table_field_from_field_type(TABLE *table, bool fixed_length);
1025
  virtual Item_field *filed_for_view_update() { return 0; }
unknown's avatar
unknown committed
1026

1027
  virtual Item *neg_transformer(THD *thd) { return NULL; }
1028
  virtual Item *update_value_transformer(uchar *select_arg) { return this; }
unknown's avatar
unknown committed
1029
  virtual Item *safe_charset_converter(CHARSET_INFO *tocs);
1030 1031 1032 1033
  void delete_self()
  {
    cleanup();
    delete this;
unknown's avatar
unknown committed
1034
  }
1035 1036

  virtual bool is_splocal() { return 0; } /* Needed for error checking */
1037 1038 1039 1040 1041 1042 1043 1044 1045

  /*
    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;
  }
1046 1047
  virtual Field::geometry_type get_geometry_type() const
    { return Field::GEOM_GEOMETRY; };
1048
  String *check_well_formed_result(String *str, bool send_error= 0);
unknown's avatar
unknown committed
1049
  bool eq_by_collation(Item *item, bool binary_cmp, CHARSET_INFO *cs); 
unknown's avatar
unknown committed
1050 1051 1052
};


1053 1054
class sp_head;

1055

1056 1057
class Item_basic_constant :public Item
{
1058
  table_map used_table_map;
1059
public:
1060 1061 1062
  Item_basic_constant(): Item(), used_table_map(0) {};
  void set_used_tables(table_map map) { used_table_map= map; }
  table_map used_tables() const { return used_table_map; }
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
  /* 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;
  }
};


1077 1078 1079 1080 1081 1082 1083 1084
/*****************************************************************************
  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
1085
{
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095
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;

1096
public:
1097 1098 1099 1100 1101
#ifndef DBUG_OFF
  /*
    Routine to which this Item_splocal belongs. Used for checking if correct
    runtime context is used for variable handling.
  */
1102
  sp_head *m_sp;
1103
#endif
1104

1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
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
1137
    it->set_name(m_name.str, (uint) m_name.length, system_charset_info);
1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
  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.
*****************************************************************************/

1162 1163
class Item_splocal :public Item_sp_variable,
                    private Settable_routine_parameter
1164 1165 1166 1167 1168
{
  uint m_var_idx;

  Type m_type;
  Item_result m_result_type;
1169
  enum_field_types m_field_type;
1170
public:
1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
  /* 
    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.
  */
1181
  uint pos_in_query;
unknown's avatar
unknown committed
1182 1183 1184 1185 1186 1187 1188 1189
  /*
    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;
1190

1191
  Item_splocal(const LEX_STRING &sp_var_name, uint sp_var_idx,
unknown's avatar
unknown committed
1192 1193
               enum_field_types sp_var_type,
               uint pos_in_q= 0, uint len_in_q= 0);
1194

1195 1196
  bool is_splocal() { return 1; } /* Needed for error checking */

1197
  Item *this_item();
1198
  const Item *this_item() const;
1199
  Item **this_item_addr(THD *thd, Item **);
1200

1201
  virtual void print(String *str, enum_query_type query_type);
unknown's avatar
unknown committed
1202

1203 1204
public:
  inline const LEX_STRING *my_name() const;
1205

1206
  inline uint get_var_idx() const;
1207

1208 1209
  inline enum Type type() const;
  inline Item_result result_type() const;
1210
  inline enum_field_types field_type() const { return m_field_type; }
1211 1212

private:
1213
  bool set_value(THD *thd, sp_rcontext *ctx, Item **it);
1214 1215 1216 1217 1218 1219

public:
  Settable_routine_parameter *get_settable_routine_parameter()
  {
    return this;
  }
1220
};
1221

1222 1223 1224
/*****************************************************************************
  Item_splocal inline implementation.
*****************************************************************************/
1225

1226 1227 1228 1229
inline const LEX_STRING *Item_splocal::my_name() const
{
  return &m_name;
}
1230

1231 1232 1233 1234
inline uint Item_splocal::get_var_idx() const
{
  return m_var_idx;
}
1235

1236 1237 1238 1239
inline enum Item::Type Item_splocal::type() const
{
  return m_type;
}
1240

1241 1242 1243 1244
inline Item_result Item_splocal::result_type() const
{
  return m_result_type;
}
unknown's avatar
unknown committed
1245

1246 1247 1248 1249 1250 1251 1252 1253

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

class Item_case_expr :public Item_sp_variable
{
public:
1254
  Item_case_expr(uint case_expr_id);
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269

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.
  */
1270
  virtual void print(String *str, enum_query_type query_type);
1271 1272

private:
1273
  uint m_case_expr_id;
1274 1275
};

1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
/*****************************************************************************
  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();
}

1290

1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
/*
  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;
1309
  bool valid_args;
1310
public:
1311
  Item_name_const(Item *name_arg, Item *val);
1312 1313 1314 1315 1316 1317 1318 1319 1320

  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();
1321
  virtual void print(String *str, enum_query_type query_type);
1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337

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

1338
  bool send(Protocol *protocol, String *str)
1339 1340 1341 1342 1343
  {
    return value_item->send(protocol, str);
  }
};

1344
bool agg_item_collations(DTCollation &c, const char *name,
1345
                         Item **items, uint nitems, uint flags, int item_sep);
1346
bool agg_item_collations_for_comparison(DTCollation &c, const char *name,
1347
                                        Item **items, uint nitems, uint flags);
1348 1349
bool agg_item_set_converter(DTCollation &coll, const char *fname,
                            Item **args, uint nargs, uint flags, int item_sep);
1350
bool agg_item_charsets(DTCollation &c, const char *name,
1351
                       Item **items, uint nitems, uint flags, int item_sep);
1352 1353


1354
class Item_num: public Item_basic_constant
1355 1356
{
public:
1357
  Item_num() {}                               /* Remove gcc warning */
unknown's avatar
unknown committed
1358
  virtual Item_num *neg()= 0;
unknown's avatar
unknown committed
1359
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1360
  bool check_partition_func_processor(uchar *int_arg) { return FALSE;}
1361 1362
};

1363
#define NO_CACHED_FIELD_INDEX ((uint)(-1))
1364

unknown's avatar
unknown committed
1365
class st_select_lex;
unknown's avatar
unknown committed
1366 1367
class Item_ident :public Item
{
1368
protected:
1369 1370 1371 1372 1373 1374 1375 1376 1377
  /* 
    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;
1378

unknown's avatar
unknown committed
1379
public:
1380
  Name_resolution_context *context;
unknown's avatar
unknown committed
1381 1382 1383
  const char *db_name;
  const char *table_name;
  const char *field_name;
unknown's avatar
unknown committed
1384
  bool alias_name_used; /* true if item was resolved against alias */
1385 1386
  /* 
    Cached value of index for this field in table->field array, used by prep. 
1387 1388 1389 1390 1391 1392 1393 1394
    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.
1395
  */
1396
  TABLE_LIST *cached_table;
unknown's avatar
unknown committed
1397
  st_select_lex *depended_from;
1398 1399 1400
  Item_ident(Name_resolution_context *context_arg,
             const char *db_name_arg, const char *table_name_arg,
             const char *field_name_arg);
unknown's avatar
unknown committed
1401
  Item_ident(THD *thd, Item_ident *item);
1402
  Item_ident(TABLE_LIST *view_arg, const char *field_name_arg);
unknown's avatar
unknown committed
1403
  const char *full_name() const;
1404
  void cleanup();
1405
  bool remove_dependence_processor(uchar * arg);
1406
  virtual void print(String *str, enum_query_type query_type);
1407
  virtual bool change_context_processor(uchar *cntx)
1408
    { context= (Name_resolution_context *)cntx; return FALSE; }
unknown's avatar
unknown committed
1409 1410 1411 1412
  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);
unknown's avatar
unknown committed
1413 1414
};

1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436

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


1437 1438
class Item_equal;
class COND_EQUAL;
unknown's avatar
unknown committed
1439

unknown's avatar
unknown committed
1440 1441
class Item_field :public Item_ident
{
1442
protected:
unknown's avatar
unknown committed
1443 1444 1445
  void set_field(Field *field);
public:
  Field *field,*result_field;
unknown's avatar
unknown committed
1446 1447
  Item_equal *item_equal;
  bool no_const_subst;
unknown's avatar
VIEW  
unknown committed
1448 1449 1450 1451 1452 1453 1454
  /*
    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;
1455 1456 1457
  Item_field(Name_resolution_context *context_arg,
             const char *db_arg,const char *table_name_arg,
	     const char *field_name_arg);
1458 1459 1460
  /*
    Constructor needed to process subselect with temporary tables (see Item)
  */
1461
  Item_field(THD *thd, Item_field *item);
1462
  /*
1463 1464 1465
    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).
1466
  */
1467
  Item_field(THD *thd, Name_resolution_context *context_arg, Field *field);
1468 1469 1470
  /*
    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
1471
    reset_field() before fix_fields() for all fields created this way.
1472
  */
unknown's avatar
unknown committed
1473 1474
  Item_field(Field *field);
  enum Type type() const { return FIELD_ITEM; }
1475
  bool eq(const Item *item, bool binary_cmp) const;
1476
  double val_real();
unknown's avatar
unknown committed
1477
  longlong val_int();
unknown's avatar
unknown committed
1478
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
1479 1480 1481 1482
  String *val_str(String*);
  double val_result();
  longlong val_int_result();
  String *str_result(String* tmp);
unknown's avatar
unknown committed
1483 1484
  my_decimal *val_decimal_result(my_decimal *);
  bool val_bool_result();
1485
  bool is_null_result();
1486
  bool send(Protocol *protocol, String *str_arg);
1487
  void reset_field(Field *f);
1488
  bool fix_fields(THD *, Item **);
1489
  void make_field(Send_field *tmp_field);
unknown's avatar
unknown committed
1490
  int save_in_field(Field *field,bool no_conversions);
unknown's avatar
unknown committed
1491 1492 1493 1494 1495 1496
  void save_org_in_field(Field *field);
  table_map used_tables() const;
  enum Item_result result_type () const
  {
    return field->result_type();
  }
1497 1498
  Item_result cast_to_int_type() const
  {
Sergei Golubchik's avatar
Sergei Golubchik committed
1499
    return field->cmp_type();
1500
  }
unknown's avatar
unknown committed
1501
  enum_field_types field_type() const
1502 1503 1504
  {
    return field->type();
  }
unknown's avatar
unknown committed
1505 1506 1507 1508
  enum_monotonicity_info get_monotonicity_info() const
  {
    return MONOTONIC_STRICT_INCREASING;
  }
1509
  longlong val_int_endpoint(bool left_endp, bool *incl_endp);
1510
  Field *get_tmp_table_field() { return result_field; }
1511
  Field *tmp_table_field(TABLE *t_arg) { return result_field; }
1512 1513
  bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
  bool get_date_result(MYSQL_TIME *ltime,uint fuzzydate);
unknown's avatar
unknown committed
1514
  bool is_null() { return field->is_null(); }
1515
  void update_null_value();
1516
  Item *get_tmp_table_item(THD *thd);
1517 1518 1519 1520
  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;}
unknown's avatar
unknown committed
1521
  void cleanup();
1522
  Item_equal *find_item_equal(COND_EQUAL *cond_equal);
1523 1524 1525 1526
  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);
1527
  inline uint32 max_disp_length() { return field->max_display_length(); }
1528
  Item_field *filed_for_view_update() { return this; }
unknown's avatar
unknown committed
1529
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1530
  int fix_outer_field(THD *thd, Field **field, Item **reference);
1531
  virtual Item *update_value_transformer(uchar *select_arg);
1532
  virtual void print(String *str, enum_query_type query_type);
1533
  Field::geometry_type get_geometry_type() const
1534 1535 1536 1537
  {
    DBUG_ASSERT(field_type() == MYSQL_TYPE_GEOMETRY);
    return field->get_geometry_type();
  }
unknown's avatar
SCRUM  
unknown committed
1538
  friend class Item_default_value;
unknown's avatar
unknown committed
1539
  friend class Item_insert_value;
unknown's avatar
unknown committed
1540
  friend class st_select_lex_unit;
unknown's avatar
unknown committed
1541 1542
};

1543
class Item_null :public Item_basic_constant
unknown's avatar
unknown committed
1544 1545 1546
{
public:
  Item_null(char *name_par=0)
unknown's avatar
unknown committed
1547 1548 1549 1550 1551
  {
    maybe_null= null_value= TRUE;
    max_length= 0;
    name= name_par ? name_par : (char*) "NULL";
    fixed= 1;
1552
    collation.set(&my_charset_bin, DERIVATION_IGNORABLE);
unknown's avatar
unknown committed
1553
  }
unknown's avatar
unknown committed
1554
  enum Type type() const { return NULL_ITEM; }
1555
  bool eq(const Item *item, bool binary_cmp) const;
1556
  double val_real();
unknown's avatar
unknown committed
1557 1558
  longlong val_int();
  String *val_str(String *str);
unknown's avatar
unknown committed
1559
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
1560
  int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
1561
  int save_safe_in_field(Field *field);
unknown's avatar
unknown committed
1562
  bool send(Protocol *protocol, String *str);
1563 1564
  enum Item_result result_type () const { return STRING_RESULT; }
  enum_field_types field_type() const   { return MYSQL_TYPE_NULL; }
unknown's avatar
unknown committed
1565
  bool basic_const_item() const { return 1; }
1566
  Item *clone_item() { return new Item_null(name); }
unknown's avatar
unknown committed
1567
  bool is_null() { return 1; }
1568 1569 1570 1571 1572 1573

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

unknown's avatar
unknown committed
1574
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1575
  bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
unknown's avatar
unknown committed
1576 1577
};

unknown's avatar
unknown committed
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587
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);
  }
1588
  bool check_partition_func_processor(uchar *int_arg) {return TRUE;}
unknown's avatar
unknown committed
1589
};  
1590 1591 1592

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

unknown's avatar
unknown committed
1593 1594
class Item_param :public Item
{
unknown's avatar
unknown committed
1595 1596 1597 1598
  char cnvbuf[MAX_FIELD_WIDTH];
  String cnvstr;
  Item *cnvitem;

1599
public:
1600 1601 1602
  enum enum_item_param_state
  {
    NO_VALUE, NULL_VALUE, INT_VALUE, REAL_VALUE,
unknown's avatar
unknown committed
1603 1604
    STRING_VALUE, TIME_VALUE, LONG_DATA_VALUE,
    DECIMAL_VALUE
1605 1606
  } state;

1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617
  /*
    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;
unknown's avatar
unknown committed
1618
  my_decimal decimal_value;
1619 1620
  union
  {
1621 1622
    longlong integer;
    double   real;
1623 1624 1625 1626 1627 1628 1629 1630 1631
    /*
      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;
1632
      CHARSET_INFO *character_set_of_placeholder;
1633 1634 1635
      /*
        This points at character set of connection if conversion
        to it is required (i. e. if placeholder typecode is not BLOB).
1636
        Otherwise it's equal to character_set_client (to simplify
1637 1638 1639 1640
        check in convert_str_value()).
      */
      CHARSET_INFO *final_character_set_of_str_value;
    } cs_info;
1641
    MYSQL_TIME     time;
1642 1643 1644
  } value;

  /* Cached values for virtual methods to save us one switch.  */
unknown's avatar
unknown committed
1645 1646
  enum Item_result item_result_type;
  enum Type item_type;
1647 1648 1649 1650 1651 1652 1653 1654 1655 1656

  /*
    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;
1657
  /*
1658 1659
    Offset of placeholder inside statement text. Used to create
    no-placeholders version of this statement for the binary log.
1660
  */
1661
  uint pos_in_query;
unknown's avatar
unknown committed
1662

1663 1664 1665
  Item_param(uint pos_in_query_arg);

  enum Item_result result_type () const { return item_result_type; }
1666
  enum Item_result cast_to_int_type() const { return item_result_type; }
unknown's avatar
unknown committed
1667
  enum Type type() const { return item_type; }
1668
  enum_field_types field_type() const { return param_type; }
1669

1670
  double val_real();
unknown's avatar
unknown committed
1671
  longlong val_int();
unknown's avatar
unknown committed
1672
  my_decimal *val_decimal(my_decimal*);
unknown's avatar
unknown committed
1673
  String *val_str(String*);
1674
  bool get_date(MYSQL_TIME *tm, uint fuzzydate);
unknown's avatar
unknown committed
1675
  int  save_in_field(Field *field, bool no_conversions);
1676

unknown's avatar
unknown committed
1677
  void set_null();
1678
  void set_int(longlong i, uint32 max_length_arg);
unknown's avatar
unknown committed
1679
  void set_double(double i);
unknown's avatar
unknown committed
1680
  void set_decimal(const char *str, ulong length);
1681 1682
  bool set_str(const char *str, ulong length);
  bool set_longdata(const char *str, ulong length);
1683
  void set_time(MYSQL_TIME *tm, timestamp_type type, uint32 max_length_arg);
1684
  bool set_from_user_var(THD *thd, const user_var_entry *entry);
1685
  void reset();
1686 1687 1688 1689 1690 1691 1692 1693
  /*
    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);

1694 1695 1696
  const String *query_val_str(String *str) const;

  bool convert_str_value(THD *thd);
1697 1698 1699 1700

  /*
    If value for parameter was not set we treat it as non-const
    so noone will use parameters value in fix_fields still
1701 1702 1703
    parameter is constant during execution.
  */
  virtual table_map used_tables() const
1704
  { return state != NO_VALUE ? (table_map)0 : PARAM_TABLE_BIT; }
1705
  virtual void print(String *str, enum_query_type query_type);
1706 1707
  bool is_null()
  { DBUG_ASSERT(state != NO_VALUE); return state == NULL_VALUE; }
1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718
  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.
  */
1719
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1720
  Item *clone_item();
1721 1722 1723 1724 1725 1726
  /*
    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;
1727 1728
  /** Item is a argument to a limit clause. */
  bool limit_clause_param;
unknown's avatar
unknown committed
1729
  void set_param_type_and_swap_value(Item_param *from);
unknown's avatar
unknown committed
1730
};
unknown's avatar
unknown committed
1731

1732

1733
class Item_int :public Item_num
unknown's avatar
unknown committed
1734 1735
{
public:
1736
  longlong value;
1737 1738
  Item_int(int32 i,uint length= MY_INT32_NUM_DECIMAL_DIGITS)
    :value((longlong) i)
1739
    { max_length=length; fixed= 1; }
1740 1741
  Item_int(longlong i,uint length= MY_INT64_NUM_DECIMAL_DIGITS)
    :value(i)
unknown's avatar
unknown committed
1742
    { max_length=length; fixed= 1; }
1743 1744
  Item_int(ulonglong i, uint length= MY_INT64_NUM_DECIMAL_DIGITS)
    :value((longlong)i)
1745
    { max_length=length; fixed= 1; unsigned_flag= 1; }
unknown's avatar
unknown committed
1746
  Item_int(const char *str_arg,longlong i,uint length) :value(i)
1747
    { max_length=length; name=(char*) str_arg; fixed= 1; }
unknown's avatar
unknown committed
1748
  Item_int(const char *str_arg, uint length=64);
unknown's avatar
unknown committed
1749
  enum Type type() const { return INT_ITEM; }
1750 1751
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types field_type() const { return MYSQL_TYPE_LONGLONG; }
1752
  longlong val_int() { DBUG_ASSERT(fixed == 1); return value; }
1753
  double val_real() { DBUG_ASSERT(fixed == 1); return (double) value; }
unknown's avatar
unknown committed
1754
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
1755
  String *val_str(String*);
unknown's avatar
unknown committed
1756
  int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
1757
  bool basic_const_item() const { return 1; }
1758
  Item *clone_item() { return new Item_int(name,value,max_length); }
1759
  virtual void print(String *str, enum_query_type query_type);
unknown's avatar
unknown committed
1760
  Item_num *neg() { value= -value; return this; }
unknown's avatar
unknown committed
1761 1762
  uint decimal_precision() const
  { return (uint)(max_length - test(value < 0)); }
1763
  bool eq(const Item *, bool binary_cmp) const;
unknown's avatar
unknown committed
1764
  bool check_partition_func_processor(uchar *bool_arg) { return FALSE;}
unknown's avatar
unknown committed
1765 1766 1767
};


unknown's avatar
unknown committed
1768 1769 1770
class Item_uint :public Item_int
{
public:
unknown's avatar
unknown committed
1771
  Item_uint(const char *str_arg, uint length);
1772
  Item_uint(ulonglong i) :Item_int(i, 10) {}
1773
  Item_uint(const char *str_arg, longlong i, uint length);
1774
  double val_real()
1775
    { DBUG_ASSERT(fixed == 1); return ulonglong2double((ulonglong)value); }
unknown's avatar
unknown committed
1776
  String *val_str(String*);
1777
  Item *clone_item() { return new Item_uint(name, value, max_length); }
1778
  virtual void print(String *str, enum_query_type query_type);
unknown's avatar
unknown committed
1779
  Item_num *neg ();
unknown's avatar
unknown committed
1780
  uint decimal_precision() const { return max_length; }
unknown's avatar
unknown committed
1781
  bool check_partition_func_processor(uchar *bool_arg) { return FALSE;}
unknown's avatar
unknown committed
1782 1783 1784
};


1785 1786 1787 1788 1789 1790 1791 1792
class Item_datetime :public Item_int
{
protected:
  MYSQL_TIME ltime;
public:
  Item_datetime() :Item_int(0) { unsigned_flag=0; }
  int save_in_field(Field *field, bool no_conversions);
  longlong val_int();
1793
  double val_real() { return (double)val_int(); }
1794 1795 1796 1797
  void set(longlong packed);
};


unknown's avatar
unknown committed
1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809
/* 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);
1810
  Item_decimal(const uchar *bin, int precision, int scale);
unknown's avatar
unknown committed
1811 1812 1813 1814 1815 1816 1817 1818 1819 1820

  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; }
1821
  Item *clone_item()
unknown's avatar
unknown committed
1822 1823 1824
  {
    return new Item_decimal(name, &decimal_value, decimals, max_length);
  }
1825
  virtual void print(String *str, enum_query_type query_type);
unknown's avatar
unknown committed
1826 1827 1828 1829 1830 1831
  Item_num *neg()
  {
    my_decimal_neg(&decimal_value);
    unsigned_flag= !decimal_value.sign();
    return this;
  }
unknown's avatar
unknown committed
1832
  uint decimal_precision() const { return decimal_value.precision(); }
1833
  bool eq(const Item *, bool binary_cmp) const;
1834
  void set_decimal_value(my_decimal *value_par);
unknown's avatar
unknown committed
1835
  bool check_partition_func_processor(uchar *bool_arg) { return FALSE;}
unknown's avatar
unknown committed
1836 1837
};

1838

unknown's avatar
unknown committed
1839
class Item_float :public Item_num
unknown's avatar
unknown committed
1840
{
1841
  char *presentation;
unknown's avatar
unknown committed
1842
public:
1843
  double value;
unknown's avatar
unknown committed
1844
  // Item_real() :value(0) {}
unknown's avatar
unknown committed
1845 1846
  Item_float(const char *str_arg, uint length);
  Item_float(const char *str,double val_arg,uint decimal_par,uint length)
unknown's avatar
unknown committed
1847 1848
    :value(val_arg)
  {
1849
    presentation= name=(char*) str;
unknown's avatar
unknown committed
1850
    decimals=(uint8) decimal_par;
unknown's avatar
unknown committed
1851
    max_length=length;
unknown's avatar
unknown committed
1852
    fixed= 1;
unknown's avatar
unknown committed
1853
  }
1854 1855 1856 1857 1858
  Item_float(double value_par, uint decimal_par) :presentation(0), value(value_par)
  {
    decimals= (uint8) decimal_par;
    fixed= 1;
  }
unknown's avatar
unknown committed
1859
  int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
1860
  enum Type type() const { return REAL_ITEM; }
1861
  enum_field_types field_type() const { return MYSQL_TYPE_DOUBLE; }
1862
  double val_real() { DBUG_ASSERT(fixed == 1); return value; }
1863 1864 1865
  longlong val_int()
  {
    DBUG_ASSERT(fixed == 1);
1866 1867 1868 1869 1870 1871 1872 1873
    if (value <= (double) LONGLONG_MIN)
    {
       return LONGLONG_MIN;
    }
    else if (value >= (double) (ulonglong) LONGLONG_MAX)
    {
      return LONGLONG_MAX;
    }
1874
    return (longlong) rint(value);
1875
  }
unknown's avatar
unknown committed
1876
  String *val_str(String*);
unknown's avatar
unknown committed
1877
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
1878
  bool basic_const_item() const { return 1; }
1879
  Item *clone_item()
unknown's avatar
unknown committed
1880
  { return new Item_float(name, value, decimals, max_length); }
unknown's avatar
unknown committed
1881
  Item_num *neg() { value= -value; return this; }
1882
  virtual void print(String *str, enum_query_type query_type);
1883
  bool eq(const Item *, bool binary_cmp) const;
unknown's avatar
unknown committed
1884 1885 1886
};


unknown's avatar
unknown committed
1887
class Item_static_float_func :public Item_float
1888 1889 1890
{
  const char *func_name;
public:
unknown's avatar
unknown committed
1891
  Item_static_float_func(const char *str, double val_arg, uint decimal_par,
1892
                        uint length)
unknown's avatar
unknown committed
1893
    :Item_float(NullS, val_arg, decimal_par, length), func_name(str)
1894
  {}
1895 1896 1897 1898 1899 1900

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

1901
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1902 1903 1904
};


1905
class Item_string :public Item_basic_constant
unknown's avatar
unknown committed
1906 1907
{
public:
unknown's avatar
unknown committed
1908
  Item_string(const char *str,uint length,
1909 1910
              CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE,
              uint repertoire= MY_REPERTOIRE_UNICODE30)
1911
    : m_cs_specified(FALSE)
unknown's avatar
unknown committed
1912
  {
1913 1914
    str_value.set_or_copy_aligned(str, length, cs);
    collation.set(cs, dv, repertoire);
1915 1916 1917 1918
    /*
      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
unknown's avatar
unknown committed
1919
      number of chars for a string of this type because we in Create_field::
1920 1921
      divide the max_length with mbmaxlen).
    */
1922
    max_length= str_value.numchars()*cs->mbmaxlen;
unknown's avatar
unknown committed
1923
    set_name(str, length, cs);
unknown's avatar
unknown committed
1924
    decimals=NOT_FIXED_DEC;
1925 1926
    // it is constant => can be used without fix_fields (and frequently used)
    fixed= 1;
unknown's avatar
unknown committed
1927
  }
1928 1929
  /* Just create an item and do not fill string representation */
  Item_string(CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE)
1930
    : m_cs_specified(FALSE)
1931 1932 1933 1934 1935 1936 1937
  {
    collation.set(cs, dv);
    max_length= 0;
    set_name(NULL, 0, cs);
    decimals= NOT_FIXED_DEC;
    fixed= 1;
  }
1938
  Item_string(const char *name_par, const char *str, uint length,
1939 1940
              CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE,
              uint repertoire= MY_REPERTOIRE_UNICODE30)
1941
    : m_cs_specified(FALSE)
unknown's avatar
unknown committed
1942
  {
1943 1944
    str_value.set_or_copy_aligned(str, length, cs);
    collation.set(cs, dv, repertoire);
1945
    max_length= str_value.numchars()*cs->mbmaxlen;
1946
    set_name(name_par, 0, cs);
unknown's avatar
unknown committed
1947
    decimals=NOT_FIXED_DEC;
1948 1949
    // it is constant => can be used without fix_fields (and frequently used)
    fixed= 1;
unknown's avatar
unknown committed
1950
  }
1951 1952 1953 1954 1955 1956 1957 1958 1959
  /*
    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;
  }
1960 1961 1962 1963 1964 1965
  void set_repertoire_from_value()
  {
    collation.repertoire= my_string_repertoire(str_value.charset(),
                                               str_value.ptr(),
                                               str_value.length());
  }
unknown's avatar
unknown committed
1966
  enum Type type() const { return STRING_ITEM; }
1967 1968
  double val_real();
  longlong val_int();
1969 1970 1971 1972 1973
  String *val_str(String*)
  {
    DBUG_ASSERT(fixed == 1);
    return (String*) &str_value;
  }
unknown's avatar
unknown committed
1974
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
1975
  int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
1976
  enum Item_result result_type () const { return STRING_RESULT; }
1977
  enum_field_types field_type() const { return MYSQL_TYPE_VARCHAR; }
unknown's avatar
unknown committed
1978
  bool basic_const_item() const { return 1; }
1979
  bool eq(const Item *item, bool binary_cmp) const;
1980
  Item *clone_item() 
1981
  {
1982
    return new Item_string(name, str_value.ptr(), 
unknown's avatar
unknown committed
1983
    			   str_value.length(), collation.collation);
1984
  }
unknown's avatar
unknown committed
1985
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1986 1987 1988 1989 1990
  inline void append(char *str, uint length)
  {
    str_value.append(str, length);
    max_length= str_value.numchars() * collation.collation->mbmaxlen;
  }
1991
  virtual void print(String *str, enum_query_type query_type);
1992
  bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034

  /**
    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;
unknown's avatar
unknown committed
2035 2036
};

2037

2038 2039 2040 2041 2042
longlong 
longlong_from_string_with_check (CHARSET_INFO *cs, const char *cptr, char *end);
double 
double_from_string_with_check (CHARSET_INFO *cs, const char *cptr, char *end);

2043 2044 2045 2046 2047 2048 2049 2050 2051
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)
  {}
2052
  Item *safe_charset_converter(CHARSET_INFO *tocs);
2053 2054 2055 2056 2057 2058

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

2059
  bool check_partition_func_processor(uchar *int_arg) {return TRUE;}
2060 2061 2062
};


unknown's avatar
unknown committed
2063
/* for show tables */
2064
class Item_partition_func_safe_string: public Item_string
unknown's avatar
unknown committed
2065 2066
{
public:
2067 2068 2069 2070
  Item_partition_func_safe_string(const char *name, uint length,
                                  CHARSET_INFO *cs= NULL):
    Item_string(name, length, cs)
  {}
unknown's avatar
unknown committed
2071 2072
};

2073 2074 2075 2076 2077

class Item_return_date_time :public Item_partition_func_safe_string
{
  enum_field_types date_time_field_type;
public:
2078 2079 2080
  Item_return_date_time(const char *name_arg, uint length_arg,
                        enum_field_types field_type_arg)
    :Item_partition_func_safe_string(name_arg, length_arg, &my_charset_bin),
2081
     date_time_field_type(field_type_arg)
2082
  { decimals= 0; }
2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097
  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; }
};


2098 2099 2100 2101 2102 2103
/**
  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.
*/

2104
class Item_empty_string :public Item_partition_func_safe_string
unknown's avatar
unknown committed
2105 2106
{
public:
2107
  Item_empty_string(const char *header,uint length, CHARSET_INFO *cs= NULL) :
2108
    Item_partition_func_safe_string("",0, cs ? cs : &my_charset_utf8_general_ci)
2109
    { name=(char*) header; max_length= length * collation.collation->mbmaxlen; }
2110
  void make_field(Send_field *field);
unknown's avatar
unknown committed
2111 2112
};

2113

2114 2115 2116 2117
class Item_return_int :public Item_int
{
  enum_field_types int_field_type;
public:
2118
  Item_return_int(const char *name_arg, uint length,
2119 2120
		  enum_field_types field_type_arg, longlong value= 0)
    :Item_int(name_arg, value, length), int_field_type(field_type_arg)
2121 2122 2123 2124 2125 2126 2127
  {
    unsigned_flag=1;
  }
  enum_field_types field_type() const { return int_field_type; }
};


2128
class Item_hex_string: public Item_basic_constant
unknown's avatar
unknown committed
2129 2130
{
public:
Georgi Kodinov's avatar
Georgi Kodinov committed
2131
  Item_hex_string();
unknown's avatar
unknown committed
2132
  Item_hex_string(const char *str,uint str_length);
unknown's avatar
unknown committed
2133
  enum Type type() const { return VARBIN_ITEM; }
2134
  double val_real()
unknown's avatar
unknown committed
2135 2136 2137 2138
  { 
    DBUG_ASSERT(fixed == 1); 
    return (double) (ulonglong) Item_hex_string::val_int();
  }
unknown's avatar
unknown committed
2139
  longlong val_int();
unknown's avatar
unknown committed
2140
  bool basic_const_item() const { return 1; }
2141
  String *val_str(String*) { DBUG_ASSERT(fixed == 1); return &str_value; }
unknown's avatar
unknown committed
2142
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
2143
  int save_in_field(Field *field, bool no_conversions);
2144
  enum Item_result result_type () const { return STRING_RESULT; }
2145
  enum Item_result cast_to_int_type() const { return INT_RESULT; }
2146
  enum_field_types field_type() const { return MYSQL_TYPE_VARCHAR; }
2147
  virtual void print(String *str, enum_query_type query_type);
2148
  bool eq(const Item *item, bool binary_cmp) const;
unknown's avatar
unknown committed
2149
  virtual Item *safe_charset_converter(CHARSET_INFO *tocs);
2150
  bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
Georgi Kodinov's avatar
Georgi Kodinov committed
2151 2152
private:
  void hex_string_init(const char *str, uint str_length);
unknown's avatar
unknown committed
2153 2154 2155
};


unknown's avatar
unknown committed
2156 2157 2158 2159 2160 2161
class Item_bin_string: public Item_hex_string
{
public:
  Item_bin_string(const char *str,uint str_length);
};

unknown's avatar
unknown committed
2162 2163 2164 2165 2166
class Item_result_field :public Item	/* Item with result field */
{
public:
  Field *result_field;				/* Save result here */
  Item_result_field() :result_field(0) {}
2167
  // Constructor used for Item_sum/Item_cond_and/or (see Item comment)
2168 2169
  Item_result_field(THD *thd, Item_result_field *item):
    Item(thd, item), result_field(item->result_field)
2170
  {}
unknown's avatar
unknown committed
2171
  ~Item_result_field() {}			/* Required with gcc 2.95 */
2172
  Field *get_tmp_table_field() { return result_field; }
2173
  Field *tmp_table_field(TABLE *t_arg) { return result_field; }
unknown's avatar
unknown committed
2174
  table_map used_tables() const { return 1; }
unknown's avatar
unknown committed
2175
  virtual void fix_length_and_dec()=0;
unknown's avatar
unknown committed
2176 2177 2178 2179 2180 2181
  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);
  }
2182
  void cleanup();
2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199
  /*
    This method is used for debug purposes to print the name of an
    item to the debug log. The second use of this method is as
    a helper function of print() and error messages, where it is
    applicable. To suit both goals it should return a meaningful,
    distinguishable and sintactically correct string. This method
    should not be used for runtime type identification, use enum
    {Sum}Functype and Item_func::functype()/Item_sum::sum_func()
    instead.
    Added here, to the parent class of both Item_func and Item_sum_func.

    NOTE: for Items inherited from Item_sum, func_name() return part of
    function name till first argument (including '(') to make difference in
    names for functions with 'distinct' clause and without 'distinct' and
    also to make printing of items inherited from Item_sum uniform.
  */
  virtual const char *func_name() const= 0;
unknown's avatar
unknown committed
2200 2201 2202 2203 2204
};


class Item_ref :public Item_ident
{
2205 2206
protected:
  void set_properties();
unknown's avatar
unknown committed
2207
public:
2208
  enum Ref_Type { REF, DIRECT_REF, VIEW_REF, OUTER_REF, AGGREGATE_REF };
unknown's avatar
unknown committed
2209
  Field *result_field;			 /* Save result here */
unknown's avatar
unknown committed
2210
  Item **ref;
2211 2212 2213 2214 2215
  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) {}
2216
  /*
2217 2218 2219 2220 2221 2222 2223 2224 2225 2226
    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.
    
2227 2228 2229
    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.
  */
2230
  Item_ref(Name_resolution_context *context_arg, Item **item,
unknown's avatar
unknown committed
2231 2232
           const char *table_name_arg, const char *field_name_arg,
           bool alias_name_used_arg= FALSE);
2233 2234
  Item_ref(TABLE_LIST *view_arg, Item **item,
           const char *field_name_arg, bool alias_name_used_arg= FALSE);
2235

2236
  /* Constructor need to process subselect with temporary tables (see Item) */
2237 2238
  Item_ref(THD *thd, Item_ref *item)
    :Item_ident(thd, item), result_field(item->result_field), ref(item->ref) {}
unknown's avatar
unknown committed
2239
  enum Type type() const		{ return REF_ITEM; }
2240
  bool eq(const Item *item, bool binary_cmp) const
unknown's avatar
unknown committed
2241 2242 2243 2244
  { 
    Item *it= ((Item *) item)->real_item();
    return ref && (*ref)->eq(it, binary_cmp);
  }
unknown's avatar
unknown committed
2245 2246 2247 2248 2249 2250
  double val_real();
  longlong val_int();
  my_decimal *val_decimal(my_decimal *);
  bool val_bool();
  String *val_str(String* tmp);
  bool is_null();
2251
  bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
2252 2253 2254
  double val_result();
  longlong val_int_result();
  String *str_result(String* tmp);
unknown's avatar
unknown committed
2255 2256
  my_decimal *val_decimal_result(my_decimal *);
  bool val_bool_result();
2257
  bool is_null_result();
2258
  bool send(Protocol *prot, String *tmp);
2259 2260
  void make_field(Send_field *field);
  bool fix_fields(THD *, Item **);
2261
  int save_in_field(Field *field, bool no_conversions);
unknown's avatar
unknown committed
2262
  void save_org_in_field(Field *field);
unknown's avatar
unknown committed
2263
  enum Item_result result_type () const { return (*ref)->result_type(); }
2264
  enum_field_types field_type() const   { return (*ref)->field_type(); }
unknown's avatar
unknown committed
2265 2266
  Field *get_tmp_table_field()
  { return result_field ? result_field : (*ref)->get_tmp_table_field(); }
unknown's avatar
unknown committed
2267
  Item *get_tmp_table_item(THD *thd);
2268
  table_map used_tables() const		
2269
  {
2270 2271
    return depended_from ? OUTER_REF_TABLE_BIT : (*ref)->used_tables(); 
  }
unknown's avatar
unknown committed
2272 2273 2274 2275 2276
  void update_used_tables() 
  { 
    if (!depended_from) 
      (*ref)->update_used_tables(); 
  }
2277
  table_map not_null_tables() const { return (*ref)->not_null_tables(); }
2278
  void set_result_field(Field *field)	{ result_field= field; }
unknown's avatar
unknown committed
2279 2280 2281 2282 2283
  bool is_result_field() { return 1; }
  void save_in_result_field(bool no_conversions)
  {
    (*ref)->save_in_field(result_field, no_conversions);
  }
unknown's avatar
unknown committed
2284 2285
  Item *real_item()
  {
unknown's avatar
unknown committed
2286
    return ref ? (*ref)->real_item() : this;
2287
  }
2288
  bool walk(Item_processor processor, bool walk_subquery, uchar *arg)
2289 2290 2291 2292
  {
    return (*ref)->walk(processor, walk_subquery, arg) ||
           (this->*processor)(arg);
  }
2293
  virtual void print(String *str, enum_query_type query_type);
unknown's avatar
unknown committed
2294
  void cleanup();
2295 2296
  Item_field *filed_for_view_update()
    { return (*ref)->filed_for_view_update(); }
2297
  virtual Ref_Type ref_type() { return REF; }
2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325

  // 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();
  }
unknown's avatar
unknown committed
2326 2327
};

2328

unknown's avatar
unknown committed
2329 2330 2331 2332
/*
  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.
*/
2333 2334 2335
class Item_direct_ref :public Item_ref
{
public:
2336 2337
  Item_direct_ref(Name_resolution_context *context_arg, Item **item,
                  const char *table_name_arg,
unknown's avatar
unknown committed
2338 2339 2340 2341 2342
                  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)
  {}
2343 2344
  /* Constructor need to process subselect with temporary tables (see Item) */
  Item_direct_ref(THD *thd, Item_direct_ref *item) : Item_ref(thd, item) {}
2345 2346 2347 2348 2349 2350
  Item_direct_ref(TABLE_LIST *view_arg, Item **item,
                  const char *field_name_arg,
                  bool alias_name_used_arg= FALSE)
    :Item_ref(view_arg, item, field_name_arg,
              alias_name_used_arg)
  {}
2351

unknown's avatar
unknown committed
2352 2353 2354 2355 2356 2357
  double val_real();
  longlong val_int();
  String *val_str(String* tmp);
  my_decimal *val_decimal(my_decimal *);
  bool val_bool();
  bool is_null();
2358
  bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
2359
  virtual Ref_Type ref_type() { return DIRECT_REF; }
2360 2361
};

2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375
/*
  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) {}
2376 2377 2378 2379
  Item_direct_view_ref(TABLE_LIST *view_arg, Item **item,
                       const char *field_name_arg)
    :Item_direct_ref(view_arg, item, field_name_arg)
  {}
2380 2381

  bool fix_fields(THD *, Item **);
2382
  bool eq(const Item *item, bool binary_cmp) const;
unknown's avatar
unknown committed
2383 2384 2385 2386 2387 2388
  Item *get_tmp_table_item(THD *thd)
  {
    Item *item= Item_ref::get_tmp_table_item(thd);
    item->name= name;
    return item;
  }
2389
  virtual Ref_Type ref_type() { return VIEW_REF; }
2390 2391
};

2392

2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403
/*
  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;
2404 2405 2406
class Item_outer_ref :public Item_direct_ref
{
public:
2407 2408 2409 2410 2411 2412 2413 2414
  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;
2415 2416 2417
  Item_outer_ref(Name_resolution_context *context_arg,
                 Item_field *outer_field_arg)
    :Item_direct_ref(context_arg, 0, outer_field_arg->table_name,
2418 2419 2420
                     outer_field_arg->field_name),
    outer_ref(outer_field_arg), in_sum_func(0),
    found_in_select_list(0)
2421
  {
2422
    ref= &outer_ref;
2423 2424 2425
    set_properties();
    fixed= 0;
  }
2426 2427 2428 2429 2430 2431 2432
  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)
  {}
2433 2434
  void save_in_result_field(bool no_conversions)
  {
2435
    outer_ref->save_org_in_field(result_field);
2436 2437 2438 2439 2440 2441 2442 2443 2444 2445
  }
  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; }
};


2446
class Item_in_subselect;
2447

2448 2449 2450 2451 2452 2453 2454 2455 2456 2457

/*
  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.
*/

2458 2459 2460 2461 2462
class Item_ref_null_helper: public Item_ref
{
protected:
  Item_in_subselect* owner;
public:
2463 2464 2465 2466 2467
  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) {}
2468
  double val_real();
2469 2470
  longlong val_int();
  String* val_str(String* s);
unknown's avatar
unknown committed
2471 2472
  my_decimal *val_decimal(my_decimal *);
  bool val_bool();
2473
  bool get_date(MYSQL_TIME *ltime, uint fuzzydate);
2474
  virtual void print(String *str, enum_query_type query_type);
2475 2476 2477 2478 2479 2480 2481 2482 2483
  /*
    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);
  }
2484 2485
};

2486
/*
2487
  The following class is used to optimize comparing of date and bigint columns
2488 2489 2490 2491 2492
  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.
  
2493 2494 2495 2496 2497 2498
*/

class Item_int_with_ref :public Item_int
{
  Item *ref;
public:
unknown's avatar
unknown committed
2499 2500
  Item_int_with_ref(longlong i, Item *ref_arg, my_bool unsigned_arg) :
    Item_int(i), ref(ref_arg)
2501
  {
unknown's avatar
unknown committed
2502
    unsigned_flag= unsigned_arg;
2503
  }
unknown's avatar
unknown committed
2504
  int save_in_field(Field *field, bool no_conversions)
2505
  {
2506
    return ref->save_in_field(field, no_conversions);
2507
  }
2508
  Item *clone_item();
2509
  virtual Item *real_item() { return ref; }
2510 2511
};

2512
#ifdef MYSQL_SERVER
2513
#include "gstream.h"
unknown's avatar
unknown committed
2514
#include "spatial.h"
unknown's avatar
unknown committed
2515 2516
#include "item_sum.h"
#include "item_func.h"
2517
#include "item_row.h"
unknown's avatar
unknown committed
2518 2519
#include "item_cmpfunc.h"
#include "item_strfunc.h"
2520
#include "item_geofunc.h"
unknown's avatar
unknown committed
2521
#include "item_timefunc.h"
2522
#include "item_subselect.h"
2523
#include "item_xmlfunc.h"
2524
#endif
unknown's avatar
unknown committed
2525

2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546
/**
  Base class to implement typed value caching Item classes

  Item_copy_ classes are very similar to the corresponding Item_
  classes (e.g. Item_copy_int is similar to Item_int) but they add
  the following additional functionality to Item_ :
    1. Nullability
    2. Possibility to store the value not only on instantiation time,
       but also later.
  Item_copy_ classes are a functionality subset of Item_cache_ 
  classes, as e.g. they don't support comparisons with the original Item
  as Item_cache_ classes do.
  Item_copy_ classes are used in GROUP BY calculation.
  TODO: Item_copy should be made an abstract interface and Item_copy_
  classes should inherit both the respective Item_ class and the interface.
  Ideally we should drop Item_copy_ classes altogether and merge 
  their functionality to Item_cache_ (and these should be made to inherit
  from Item_).
*/

class Item_copy :public Item
unknown's avatar
unknown committed
2547
{
2548 2549 2550 2551 2552 2553
protected:  

  /**
    Stores the type of the resulting field that would be used to store the data
    in the cache. This is to avoid calls to the original item.
  */
2554
  enum enum_field_types cached_field_type;
2555 2556

  /** The original item that is copied */
unknown's avatar
unknown committed
2557
  Item *item;
2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571

  /**
    Stores the result type of the original item, so it can be returned
    without calling the original item's method
  */
  Item_result cached_result_type;

  /**
    Constructor of the Item_copy class

    stores metadata information about the original class as well as a 
    pointer to it.
  */
  Item_copy(Item *i)
unknown's avatar
unknown committed
2572
  {
2573
    item= i;
unknown's avatar
unknown committed
2574 2575 2576 2577
    null_value=maybe_null=item->maybe_null;
    decimals=item->decimals;
    max_length=item->max_length;
    name=item->name;
2578
    cached_field_type= item->field_type();
2579 2580
    cached_result_type= item->result_type();
    unsigned_flag= item->unsigned_flag;
unknown's avatar
unknown committed
2581
  }
2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602

public:
  /** 
    Factory method to create the appropriate subclass dependent on the type of 
    the original item.

    @param item      the original item.
  */  
  static Item_copy *create (Item *item);

  /** 
    Update the cache with the value of the original item
   
    This is the method that updates the cached value.
    It must be explicitly called by the user of this class to store the value 
    of the orginal item in the cache.
  */  
  virtual void copy() = 0;

  Item *get_item() { return item; }
  /** All of the subclasses should have the same type tag */
unknown's avatar
unknown committed
2603
  enum Type type() const { return COPY_STR_ITEM; }
2604
  enum_field_types field_type() const { return cached_field_type; }
2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653
  enum Item_result result_type () const { return cached_result_type; }

  void make_field(Send_field *field) { item->make_field(field); }
  table_map used_tables() const { return (table_map) 1L; }
  bool const_item() const { return 0; }
  bool is_null() { return null_value; }

  /*  
    Override the methods below as pure virtual to make sure all the 
    sub-classes implement them.
  */  

  virtual String *val_str(String*) = 0;
  virtual my_decimal *val_decimal(my_decimal *) = 0;
  virtual double val_real() = 0;
  virtual longlong val_int() = 0;
  virtual int save_in_field(Field *field, bool no_conversions) = 0;
};

/**
 Implementation of a string cache.
 
 Uses Item::str_value for storage
*/ 
class Item_copy_string : public Item_copy
{
public:
  Item_copy_string (Item *item) : Item_copy(item) {}

  String *val_str(String*);
  my_decimal *val_decimal(my_decimal *);
  double val_real();
  longlong val_int();
  void copy();
  int save_in_field(Field *field, bool no_conversions);
};


class Item_copy_int : public Item_copy
{
protected:  
  longlong cached_value; 
public:
  Item_copy_int (Item *i) : Item_copy(i) {}
  int save_in_field(Field *field, bool no_conversions);

  virtual String *val_str(String*);
  virtual my_decimal *val_decimal(my_decimal *);
  virtual double val_real()
2654
  {
2655
    return null_value ? 0.0 : (double) cached_value;
2656
  }
2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668
  virtual longlong val_int()
  {
    return null_value ? LL(0) : cached_value;
  }
  virtual void copy();
};


class Item_copy_uint : public Item_copy_int
{
public:
  Item_copy_uint (Item *item) : Item_copy_int(item) 
unknown's avatar
unknown committed
2669
  {
2670
    unsigned_flag= 1;
2671
  }
2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688

  String *val_str(String*);
  double val_real()
  {
    return null_value ? 0.0 : (double) (ulonglong) cached_value;
  }
};


class Item_copy_float : public Item_copy
{
protected:  
  double cached_value; 
public:
  Item_copy_float (Item *i) : Item_copy(i) {}
  int save_in_field(Field *field, bool no_conversions);

unknown's avatar
unknown committed
2689
  String *val_str(String*);
unknown's avatar
unknown committed
2690
  my_decimal *val_decimal(my_decimal *);
2691
  double val_real()
2692
  {
2693
    return null_value ? 0.0 : cached_value;
2694
  }
2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722
  longlong val_int()
  {
    return (longlong) rint(val_real());
  }
  void copy()
  {
    cached_value= item->val_real();
    null_value= item->null_value;
  }
};


class Item_copy_decimal : public Item_copy
{
protected:  
  my_decimal cached_value;
public:
  Item_copy_decimal (Item *i) : Item_copy(i) {}
  int save_in_field(Field *field, bool no_conversions);

  String *val_str(String*);
  my_decimal *val_decimal(my_decimal *) 
  { 
    return null_value ? NULL: &cached_value; 
  }
  double val_real();
  longlong val_int();
  void copy();
unknown's avatar
unknown committed
2723 2724 2725
};


unknown's avatar
unknown committed
2726
class Cached_item :public Sql_alloc
unknown's avatar
unknown committed
2727 2728 2729
{
public:
  my_bool null_value;
unknown's avatar
unknown committed
2730
  Cached_item() :null_value(0) {}
unknown's avatar
unknown committed
2731
  virtual bool cmp(void)=0;
unknown's avatar
unknown committed
2732
  virtual ~Cached_item(); /*line -e1509 */
unknown's avatar
unknown committed
2733 2734
};

unknown's avatar
unknown committed
2735
class Cached_item_str :public Cached_item
unknown's avatar
unknown committed
2736 2737
{
  Item *item;
2738
  uint32 value_max_length;
unknown's avatar
unknown committed
2739 2740
  String value,tmp_value;
public:
unknown's avatar
unknown committed
2741
  Cached_item_str(THD *thd, Item *arg);
unknown's avatar
unknown committed
2742
  bool cmp(void);
unknown's avatar
unknown committed
2743
  ~Cached_item_str();                           // Deallocate String:s
unknown's avatar
unknown committed
2744 2745 2746
};


unknown's avatar
unknown committed
2747
class Cached_item_real :public Cached_item
unknown's avatar
unknown committed
2748 2749 2750 2751
{
  Item *item;
  double value;
public:
unknown's avatar
unknown committed
2752
  Cached_item_real(Item *item_par) :item(item_par),value(0.0) {}
unknown's avatar
unknown committed
2753 2754 2755
  bool cmp(void);
};

unknown's avatar
unknown committed
2756
class Cached_item_int :public Cached_item
unknown's avatar
unknown committed
2757 2758 2759 2760
{
  Item *item;
  longlong value;
public:
unknown's avatar
unknown committed
2761
  Cached_item_int(Item *item_par) :item(item_par),value(0) {}
unknown's avatar
unknown committed
2762 2763 2764 2765
  bool cmp(void);
};


unknown's avatar
unknown committed
2766
class Cached_item_decimal :public Cached_item
unknown's avatar
unknown committed
2767 2768 2769 2770
{
  Item *item;
  my_decimal value;
public:
unknown's avatar
unknown committed
2771
  Cached_item_decimal(Item *item_par);
unknown's avatar
unknown committed
2772 2773 2774
  bool cmp(void);
};

unknown's avatar
unknown committed
2775
class Cached_item_field :public Cached_item
unknown's avatar
unknown committed
2776
{
2777
  uchar *buff;
unknown's avatar
unknown committed
2778 2779 2780 2781
  Field *field;
  uint length;

public:
unknown's avatar
unknown committed
2782
  Cached_item_field(Item_field *item)
unknown's avatar
unknown committed
2783
  {
unknown's avatar
unknown committed
2784
    field= item->field;
2785
    buff= (uchar*) sql_calloc(length=field->pack_length());
unknown's avatar
unknown committed
2786 2787 2788 2789
  }
  bool cmp(void);
};

unknown's avatar
SCRUM  
unknown committed
2790 2791 2792 2793
class Item_default_value : public Item_field
{
public:
  Item *arg;
2794 2795 2796 2797 2798 2799 2800 2801
  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) {}
unknown's avatar
SCRUM  
unknown committed
2802
  enum Type type() const { return DEFAULT_VALUE_ITEM; }
unknown's avatar
SCRUM  
unknown committed
2803
  bool eq(const Item *item, bool binary_cmp) const;
2804
  bool fix_fields(THD *, Item **);
2805
  virtual void print(String *str, enum_query_type query_type);
2806
  int save_in_field(Field *field_arg, bool no_conversions);
unknown's avatar
SCRUM  
unknown committed
2807
  table_map used_tables() const { return (table_map)0L; }
unknown's avatar
unknown committed
2808

2809
  bool walk(Item_processor processor, bool walk_subquery, uchar *args)
unknown's avatar
unknown committed
2810
  {
2811
    return arg->walk(processor, walk_subquery, args) ||
unknown's avatar
unknown committed
2812 2813
      (this->*processor)(args);
  }
2814

2815
  Item *transform(Item_transformer transformer, uchar *args);
unknown's avatar
unknown committed
2816
};
unknown's avatar
unknown committed
2817

2818 2819 2820 2821 2822 2823 2824 2825 2826 2827
/*
  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.
*/

unknown's avatar
unknown committed
2828 2829 2830 2831
class Item_insert_value : public Item_field
{
public:
  Item *arg;
2832 2833 2834 2835
  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) {}
unknown's avatar
unknown committed
2836
  bool eq(const Item *item, bool binary_cmp) const;
2837
  bool fix_fields(THD *, Item **);
2838
  virtual void print(String *str, enum_query_type query_type);
2839
  int save_in_field(Field *field_arg, bool no_conversions)
unknown's avatar
unknown committed
2840
  {
2841
    return Item_field::save_in_field(field_arg, no_conversions);
unknown's avatar
unknown committed
2842
  }
2843 2844 2845 2846 2847
  /* 
   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; }
unknown's avatar
unknown committed
2848

2849
  bool walk(Item_processor processor, bool walk_subquery, uchar *args)
unknown's avatar
unknown committed
2850
  {
2851
    return arg->walk(processor, walk_subquery, args) ||
unknown's avatar
unknown committed
2852 2853
	    (this->*processor)(args);
  }
unknown's avatar
unknown committed
2854 2855
};

2856 2857 2858 2859 2860 2861 2862 2863 2864 2865

/*
  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
{
2866
  TRG_ACTION_BEFORE= 0, TRG_ACTION_AFTER= 1, TRG_ACTION_MAX
2867 2868
};

unknown's avatar
unknown committed
2869 2870
class Table_triggers_list;

2871 2872 2873 2874
/*
  Represents NEW/OLD version of field of row which is
  changed/read in trigger.

unknown's avatar
unknown committed
2875 2876 2877 2878 2879 2880
  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.
2881
*/
2882 2883
class Item_trigger_field : public Item_field,
                           private Settable_routine_parameter
2884 2885 2886 2887 2888
{
public:
  /* Is this item represents row from NEW or OLD row ? */
  enum row_version_type {OLD_ROW, NEW_ROW};
  row_version_type row_version;
2889 2890
  /* Next in list of all Item_trigger_field's in trigger */
  Item_trigger_field *next_trg_field;
unknown's avatar
unknown committed
2891 2892 2893 2894
  /* 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;
2895

2896 2897
  Item_trigger_field(Name_resolution_context *context_arg,
                     row_version_type row_ver_arg,
unknown's avatar
unknown committed
2898
                     const char *field_name_arg,
2899
                     ulong priv, const bool ro)
2900 2901
    :Item_field(context_arg,
               (const char *)NULL, (const char *)NULL, field_name_arg),
2902 2903
     row_version(row_ver_arg), field_idx((uint)-1), original_privilege(priv),
     want_privilege(priv), table_grants(NULL), read_only (ro)
2904
  {}
unknown's avatar
unknown committed
2905
  void setup_field(THD *thd, TABLE *table, GRANT_INFO *table_grant_info);
2906 2907
  enum Type type() const { return TRIGGER_FIELD_ITEM; }
  bool eq(const Item *item, bool binary_cmp) const;
2908
  bool fix_fields(THD *, Item **);
2909
  virtual void print(String *str, enum_query_type query_type);
2910
  table_map used_tables() const { return (table_map)0L; }
2911 2912 2913
  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); }
2914
  void cleanup();
unknown's avatar
unknown committed
2915 2916

private:
2917
  void set_required_privilege(bool rw);
2918
  bool set_value(THD *thd, sp_rcontext *ctx, Item **it);
2919 2920 2921 2922 2923 2924 2925

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

2926
  bool set_value(THD *thd, Item **it)
2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943
  {
    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;
unknown's avatar
unknown committed
2944
  GRANT_INFO *table_grants;
2945 2946 2947 2948 2949
  /*
    Trigger field is read-only unless it belongs to the NEW row in a
    BEFORE INSERT of BEFORE UPDATE trigger.
  */
  bool read_only;
2950 2951 2952
};


2953
class Item_cache: public Item_basic_constant
2954
{
unknown's avatar
unknown committed
2955 2956
protected:
  Item *example;
2957
  table_map used_table_map;
2958 2959 2960 2961 2962 2963 2964
  /*
    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;
2965
  enum enum_field_types cached_field_type;
2966 2967 2968 2969 2970 2971 2972 2973
  /*
    TRUE <=> cache holds value of the last stored item (i.e actual value).
    store() stores item to be cached and sets this flag to FALSE.
    On the first call of val_xxx function if this flag is set to FALSE the 
    cache_value() will be called to actually cache value of saved item.
    cache_value() will set this flag to TRUE.
  */
  bool value_cached;
2974
public:
2975 2976 2977
  Item_cache():
    example(0), used_table_map(0), cached_field(0), cached_field_type(MYSQL_TYPE_STRING),
    value_cached(0)
2978 2979 2980 2981 2982
  {
    fixed= 1; 
    null_value= 1;
  }
  Item_cache(enum_field_types field_type_arg):
2983 2984
    example(0), used_table_map(0), cached_field(0), cached_field_type(field_type_arg),
    value_cached(0)
2985 2986 2987 2988
  {
    fixed= 1;
    null_value= 1;
  }
2989 2990 2991

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

unknown's avatar
unknown committed
2992
  virtual bool allocate(uint i) { return 0; }
2993
  virtual bool setup(Item *item)
2994
  {
2995 2996 2997 2998
    example= item;
    max_length= item->max_length;
    decimals= item->decimals;
    collation.set(item->collation);
2999
    unsigned_flag= item->unsigned_flag;
3000 3001
    if (item->type() == FIELD_ITEM)
      cached_field= ((Item_field *)item)->field;
3002 3003
    return 0;
  };
3004
  enum Type type() const { return CACHE_ITEM; }
3005
  enum_field_types field_type() const { return cached_field_type; }
3006
  static Item_cache* get_cache(const Item *item);
3007
  static Item_cache* get_cache(const Item* item, const Item_result type);
3008
  table_map used_tables() const { return used_table_map; }
3009
  virtual void keep_array() {}
3010
  virtual void print(String *str, enum_query_type query_type);
3011 3012 3013 3014 3015 3016 3017 3018
  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;
  }
3019
  virtual void store(Item *item);
3020
  virtual bool cache_value()= 0;
3021 3022
};

unknown's avatar
unknown committed
3023

3024 3025
class Item_cache_int: public Item_cache
{
unknown's avatar
unknown committed
3026
protected:
3027 3028
  longlong value;
public:
3029
  Item_cache_int(): Item_cache(MYSQL_TYPE_LONGLONG),
3030
    value(0) {}
3031 3032
  Item_cache_int(enum_field_types field_type_arg):
    Item_cache(field_type_arg), value(0) {}
unknown's avatar
unknown committed
3033

3034
  virtual void store(Item *item){ Item_cache::store(item); }
3035
  void store(Item *item, longlong val_arg);
3036 3037
  double val_real();
  longlong val_int();
unknown's avatar
unknown committed
3038 3039
  String* val_str(String *str);
  my_decimal *val_decimal(my_decimal *);
3040
  enum Item_result result_type() const { return INT_RESULT; }
3041
  bool cache_value();
3042 3043
  bool get_date(MYSQL_TIME *ltime, uint fuzzydate);
  int save_in_field(Field *field, bool no_conversions);
Sergei Golubchik's avatar
Sergei Golubchik committed
3044 3045 3046 3047 3048
  /*
    Having a clone_item method tells optimizer that this object
    is a constant and need not be optimized further.
    Important when storing packed datetime values.
  */
3049 3050 3051 3052 3053 3054
  Item *clone_item()
  {
    Item_cache_int *item= new Item_cache_int(cached_field_type);
    item->store(this, value);
    return item;
  }
3055 3056
};

unknown's avatar
unknown committed
3057

3058 3059 3060 3061
class Item_cache_real: public Item_cache
{
  double value;
public:
3062
  Item_cache_real(): Item_cache(MYSQL_TYPE_DOUBLE),
3063
    value(0) {}
3064

3065
  double val_real();
unknown's avatar
unknown committed
3066 3067 3068
  longlong val_int();
  String* val_str(String *str);
  my_decimal *val_decimal(my_decimal *);
3069
  enum Item_result result_type() const { return REAL_RESULT; }
3070
  bool cache_value();
3071 3072
};

unknown's avatar
unknown committed
3073 3074 3075 3076 3077 3078

class Item_cache_decimal: public Item_cache
{
protected:
  my_decimal decimal_value;
public:
3079
  Item_cache_decimal(): Item_cache(MYSQL_TYPE_NEWDECIMAL) {}
unknown's avatar
unknown committed
3080 3081 3082 3083 3084 3085

  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; }
3086
  bool cache_value();
unknown's avatar
unknown committed
3087 3088 3089
};


3090 3091
class Item_cache_str: public Item_cache
{
unknown's avatar
unknown committed
3092
  char buffer[STRING_BUFFER_USUAL_SIZE];
3093
  String *value, value_buff;
3094 3095
  bool is_varbinary;
  
3096
public:
3097 3098 3099 3100 3101 3102 3103
  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())
  {}
3104
  double val_real();
3105
  longlong val_int();
3106
  String* val_str(String *);
unknown's avatar
unknown committed
3107
  my_decimal *val_decimal(my_decimal *);
3108 3109
  enum Item_result result_type() const { return STRING_RESULT; }
  CHARSET_INFO *charset() const { return value->charset(); };
3110
  int save_in_field(Field *field, bool no_conversions);
3111
  bool cache_value();
3112 3113
};

unknown's avatar
unknown committed
3114 3115 3116
class Item_cache_row: public Item_cache
{
  Item_cache  **values;
unknown's avatar
unknown committed
3117
  uint item_count;
3118
  bool save_array;
unknown's avatar
unknown committed
3119
public:
3120
  Item_cache_row()
3121 3122
    :Item_cache(), values(0), item_count(2),
    save_array(0) {}
unknown's avatar
unknown committed
3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139
  
  /*
    '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");
  };
3140
  double val_real()
unknown's avatar
unknown committed
3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154
  {
    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;
  };
unknown's avatar
unknown committed
3155 3156 3157 3158 3159 3160
  my_decimal *val_decimal(my_decimal *val)
  {
    illegal_method_call((const char*)"val_decimal");
    return 0;
  };

unknown's avatar
unknown committed
3161 3162
  enum Item_result result_type() const { return ROW_RESULT; }
  
unknown's avatar
unknown committed
3163
  uint cols() { return item_count; }
3164 3165
  Item *element_index(uint i) { return values[i]; }
  Item **addr(uint i) { return (Item **) (values + i); }
unknown's avatar
unknown committed
3166 3167 3168
  bool check_cols(uint c);
  bool null_inside();
  void bring_value();
3169
  void keep_array() { save_array= 1; }
unknown's avatar
unknown committed
3170 3171
  void cleanup()
  {
unknown's avatar
unknown committed
3172
    DBUG_ENTER("Item_cache_row::cleanup");
unknown's avatar
unknown committed
3173
    Item_cache::cleanup();
3174 3175 3176 3177
    if (save_array)
      bzero(values, item_count*sizeof(Item**));
    else
      values= 0;
unknown's avatar
unknown committed
3178
    DBUG_VOID_RETURN;
unknown's avatar
unknown committed
3179
  }
3180
  bool cache_value();
unknown's avatar
unknown committed
3181 3182
};

3183 3184

/*
3185 3186 3187 3188 3189
  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.
3190 3191 3192 3193
*/
class Item_type_holder: public Item
{
protected:
3194 3195
  TYPELIB *enum_set_typelib;
  enum_field_types fld_type;
3196
  Field::geometry_type geometry_type;
3197 3198

  void get_full_info(Item *item);
unknown's avatar
unknown committed
3199 3200 3201

  /* It is used to count decimal precision in join_types */
  int prev_decimal_int_part;
3202
public:
3203
  Item_type_holder(THD*, Item*);
3204

3205
  Item_result result_type() const;
3206
  enum_field_types field_type() const { return fld_type; };
3207
  enum Type type() const { return TYPE_HOLDER; }
3208
  double val_real();
3209
  longlong val_int();
unknown's avatar
unknown committed
3210
  my_decimal *val_decimal(my_decimal *);
3211
  String *val_str(String*);
3212 3213 3214 3215
  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 *);
3216
  Field::geometry_type get_geometry_type() const { return geometry_type; };
3217 3218
};

3219

3220 3221 3222
class st_select_lex;
void mark_select_range_as_dependent(THD *thd,
                                    st_select_lex *last_select,
unknown's avatar
unknown committed
3223
                                    st_select_lex *current_sel,
3224 3225
                                    Field *found_field, Item *found_item,
                                    Item_ident *resolved_item);
3226

unknown's avatar
unknown committed
3227
extern Cached_item *new_Cached_item(THD *thd, Item *item);
unknown's avatar
unknown committed
3228
extern Item_result item_cmp_type(Item_result a,Item_result b);
3229
extern void resolve_const_item(THD *thd, Item **ref, Item *cmp_item);
3230
extern int stored_field_cmp_to_item(THD *thd, Field *field, Item *item);