← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/item.h

  • Committer: Monty Taylor
  • Date: 2008-07-13 21:27:17 UTC
  • mto: (77.4.1 glibclient-merge)
  • mto: This revision was merged to the branch mainline in revision 153.
  • Revision ID: monty@inaugust.com-20080713212717-8r4dap6oqxopxrd6
Cleanup to hello_world Makefile.am

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/item.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
19
 
 
20
 
#ifndef drizzled_item_h
21
 
#define drizzled_item_h
 
1
/* Copyright (C) 2000-2006 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
 
 
17
#ifdef USE_PRAGMA_INTERFACE
 
18
#pragma interface                       /* gcc class implementation */
 
19
#endif
22
20
 
23
21
class Protocol;
24
 
struct TableList;
 
22
struct TABLE_LIST;
25
23
void item_init(void);                   /* Init item functions */
26
24
class Item_field;
27
25
 
49
47
 
50
48
class DTCollation {
51
49
public:
52
 
  const CHARSET_INFO *collation;
 
50
  CHARSET_INFO     *collation;
53
51
  enum Derivation derivation;
54
 
  uint32_t repertoire;
 
52
  uint repertoire;
55
53
  
56
 
  void set_repertoire_from_charset(const CHARSET_INFO * const cs)
 
54
  void set_repertoire_from_charset(CHARSET_INFO *cs)
57
55
  {
58
56
    repertoire= cs->state & MY_CS_PUREASCII ?
59
57
                MY_REPERTOIRE_ASCII : MY_REPERTOIRE_UNICODE30;
64
62
    derivation= DERIVATION_NONE;
65
63
    repertoire= MY_REPERTOIRE_UNICODE30;
66
64
  }
67
 
  DTCollation(const CHARSET_INFO * const collation_arg, Derivation derivation_arg)
 
65
  DTCollation(CHARSET_INFO *collation_arg, Derivation derivation_arg)
68
66
  {
69
67
    collation= collation_arg;
70
68
    derivation= derivation_arg;
76
74
    derivation= dt.derivation;
77
75
    repertoire= dt.repertoire;
78
76
  }
79
 
  void set(const CHARSET_INFO * const collation_arg, Derivation derivation_arg)
 
77
  void set(CHARSET_INFO *collation_arg, Derivation derivation_arg)
80
78
  {
81
79
    collation= collation_arg;
82
80
    derivation= derivation_arg;
83
81
    set_repertoire_from_charset(collation_arg);
84
82
  }
85
 
  void set(const CHARSET_INFO * const collation_arg,
 
83
  void set(CHARSET_INFO *collation_arg,
86
84
           Derivation derivation_arg,
87
 
           uint32_t repertoire_arg)
 
85
           uint repertoire_arg)
88
86
  {
89
87
    collation= collation_arg;
90
88
    derivation= derivation_arg;
91
89
    repertoire= repertoire_arg;
92
90
  }
93
 
  void set(const CHARSET_INFO * const collation_arg)
 
91
  void set(CHARSET_INFO *collation_arg)
94
92
  {
95
93
    collation= collation_arg;
96
94
    set_repertoire_from_charset(collation_arg);
97
95
  }
98
96
  void set(Derivation derivation_arg)
99
97
  { derivation= derivation_arg; }
100
 
  bool aggregate(DTCollation &dt, uint32_t flags= 0);
101
 
  bool set(DTCollation &dt1, DTCollation &dt2, uint32_t flags= 0)
 
98
  bool aggregate(DTCollation &dt, uint flags= 0);
 
99
  bool set(DTCollation &dt1, DTCollation &dt2, uint flags= 0)
102
100
  { set(dt1); return aggregate(dt2, flags); }
103
101
  const char *derivation_name() const
104
102
  {
126
124
 
127
125
struct Hybrid_type
128
126
{
129
 
  int64_t integer;
 
127
  longlong integer;
130
128
 
131
129
  double real;
132
130
  /*
164
162
  virtual void set_zero(Hybrid_type *val) const { val->real= 0.0; }
165
163
  virtual void add(Hybrid_type *val, Field *f) const
166
164
  { val->real+= f->val_real(); }
167
 
  virtual void div(Hybrid_type *val, uint64_t u) const
168
 
  { val->real/= uint64_t2double(u); }
 
165
  virtual void div(Hybrid_type *val, ulonglong u) const
 
166
  { val->real/= ulonglong2double(u); }
169
167
 
170
 
  virtual int64_t val_int(Hybrid_type *val,
171
 
                           bool unsigned_flag __attribute__((unused))) const
172
 
  { return (int64_t) rint(val->real); }
 
168
  virtual longlong val_int(Hybrid_type *val,
 
169
                           bool unsigned_flag __attribute__((__unused__))) const
 
170
  { return (longlong) rint(val->real); }
173
171
  virtual double val_real(Hybrid_type *val) const { return val->real; }
174
172
  virtual my_decimal *val_decimal(Hybrid_type *val, my_decimal *buf) const;
175
 
  virtual String *val_str(Hybrid_type *val, String *buf, uint8_t decimals) const;
 
173
  virtual String *val_str(Hybrid_type *val, String *buf, uint8 decimals) const;
176
174
  static const Hybrid_type_traits *instance();
177
175
  Hybrid_type_traits() {}
178
176
  virtual ~Hybrid_type_traits() {}
189
187
  /* Hybrid_type operations. */
190
188
  virtual void set_zero(Hybrid_type *val) const;
191
189
  virtual void add(Hybrid_type *val, Field *f) const;
192
 
  virtual void div(Hybrid_type *val, uint64_t u) const;
 
190
  virtual void div(Hybrid_type *val, ulonglong u) const;
193
191
 
194
 
  virtual int64_t val_int(Hybrid_type *val, bool unsigned_flag) const;
 
192
  virtual longlong val_int(Hybrid_type *val, bool unsigned_flag) const;
195
193
  virtual double val_real(Hybrid_type *val) const;
196
194
  virtual my_decimal *val_decimal(Hybrid_type *val,
197
 
                                  my_decimal *buf __attribute__((unused))) const
 
195
                                  my_decimal *buf __attribute__((__unused__))) const
198
196
  { return &val->dec_buf[val->used_dec_buf_no]; }
199
 
  virtual String *val_str(Hybrid_type *val, String *buf, uint8_t decimals) const;
 
197
  virtual String *val_str(Hybrid_type *val, String *buf, uint8 decimals) const;
200
198
  static const Hybrid_type_traits_decimal *instance();
201
199
  Hybrid_type_traits_decimal() {};
202
200
};
214
212
  { val->integer= 0; }
215
213
  virtual void add(Hybrid_type *val, Field *f) const
216
214
  { val->integer+= f->val_int(); }
217
 
  virtual void div(Hybrid_type *val, uint64_t u) const
218
 
  { val->integer/= (int64_t) u; }
 
215
  virtual void div(Hybrid_type *val, ulonglong u) const
 
216
  { val->integer/= (longlong) u; }
219
217
 
220
 
  virtual int64_t val_int(Hybrid_type *val,
221
 
                           bool unsigned_flag __attribute__((unused))) const
 
218
  virtual longlong val_int(Hybrid_type *val,
 
219
                           bool unsigned_flag __attribute__((__unused__))) const
222
220
  { return val->integer; }
223
221
  virtual double val_real(Hybrid_type *val) const
224
222
  { return (double) val->integer; }
225
223
  virtual my_decimal *val_decimal(Hybrid_type *val,
226
 
                                  my_decimal *buf __attribute__((unused))) const
 
224
                                  my_decimal *buf __attribute__((__unused__))) const
227
225
  {
228
226
    int2my_decimal(E_DEC_FATAL_ERROR, val->integer, 0, &val->dec_buf[2]);
229
227
    return &val->dec_buf[2];
230
228
  }
231
229
  virtual String *val_str(Hybrid_type *val, String *buf,
232
 
                          uint8_t decimals __attribute__((unused))) const
 
230
                          uint8 decimals __attribute__((__unused__))) const
233
231
  { buf->set(val->integer, &my_charset_bin); return buf;}
234
232
  static const Hybrid_type_traits_integer *instance();
235
233
  Hybrid_type_traits_integer() {};
271
269
    statements we have to change this member dynamically to ensure correct
272
270
    name resolution of different parts of the statement.
273
271
  */
274
 
  TableList *table_list;
 
272
  TABLE_LIST *table_list;
275
273
  /*
276
274
    In most cases the two table references below replace 'table_list' above
277
275
    for the purpose of name resolution. The first and last name resolution
279
277
    join tree in a FROM clause. This is needed for NATURAL JOIN, JOIN ... USING
280
278
    and JOIN ... ON. 
281
279
  */
282
 
  TableList *first_name_resolution_table;
 
280
  TABLE_LIST *first_name_resolution_table;
283
281
  /*
284
282
    Last table to search in the list of leaf table references that begins
285
283
    with first_name_resolution_table.
286
284
  */
287
 
  TableList *last_name_resolution_table;
 
285
  TABLE_LIST *last_name_resolution_table;
288
286
 
289
287
  /*
290
288
    SELECT_LEX item belong to, in case of merged VIEW it can differ from
302
300
  void *error_processor_data;
303
301
 
304
302
  /*
305
 
    When true items are resolved in this context both against the
306
 
    SELECT list and this->table_list. If false, items are resolved
 
303
    When TRUE items are resolved in this context both against the
 
304
    SELECT list and this->table_list. If FALSE, items are resolved
307
305
    only against this->table_list.
308
306
  */
309
307
  bool resolve_in_select_list;
322
320
 
323
321
  void init()
324
322
  {
325
 
    resolve_in_select_list= false;
 
323
    resolve_in_select_list= FALSE;
326
324
    error_processor= &dummy_error_processor;
327
325
    first_name_resolution_table= NULL;
328
326
    last_name_resolution_table= NULL;
329
327
  }
330
328
 
331
 
  void resolve_in_table_list_only(TableList *tables)
 
329
  void resolve_in_table_list_only(TABLE_LIST *tables)
332
330
  {
333
331
    table_list= first_name_resolution_table= tables;
334
 
    resolve_in_select_list= false;
 
332
    resolve_in_select_list= FALSE;
335
333
  }
336
334
 
337
335
  void process_error(THD *thd)
348
346
class Name_resolution_context_state
349
347
{
350
348
private:
351
 
  TableList *save_table_list;
352
 
  TableList *save_first_name_resolution_table;
353
 
  TableList *save_next_name_resolution_table;
 
349
  TABLE_LIST *save_table_list;
 
350
  TABLE_LIST *save_first_name_resolution_table;
 
351
  TABLE_LIST *save_next_name_resolution_table;
354
352
  bool        save_resolve_in_select_list;
355
 
  TableList *save_next_local;
 
353
  TABLE_LIST *save_next_local;
356
354
 
357
355
public:
358
356
  Name_resolution_context_state() {}          /* Remove gcc warning */
359
357
 
360
358
public:
361
359
  /* Save the state of a name resolution context. */
362
 
  void save_state(Name_resolution_context *context, TableList *table_list)
 
360
  void save_state(Name_resolution_context *context, TABLE_LIST *table_list)
363
361
  {
364
362
    save_table_list=                  context->table_list;
365
363
    save_first_name_resolution_table= context->first_name_resolution_table;
369
367
  }
370
368
 
371
369
  /* Restore a name resolution context from saved state. */
372
 
  void restore_state(Name_resolution_context *context, TableList *table_list)
 
370
  void restore_state(Name_resolution_context *context, TABLE_LIST *table_list)
373
371
  {
374
372
    table_list->next_local=                save_next_local;
375
373
    table_list->next_name_resolution_table= save_next_name_resolution_table;
378
376
    context->resolve_in_select_list=       save_resolve_in_select_list;
379
377
  }
380
378
 
381
 
  TableList *get_first_name_resolution_table()
 
379
  TABLE_LIST *get_first_name_resolution_table()
382
380
  {
383
381
    return save_first_name_resolution_table;
384
382
  }
393
391
  etc etc). An Item* tree is assumed to have the same monotonicity properties
394
392
  as its correspoinding function F:
395
393
 
396
 
  [signed] int64_t F(field1, field2, ...) {
 
394
  [signed] longlong F(field1, field2, ...) {
397
395
    put values of field_i into table record buffer;
398
396
    return item->val_int(); 
399
397
  }
414
412
} enum_monotonicity_info;
415
413
 
416
414
/*************************************************************************/
417
 
typedef bool (Item::*Item_processor) (unsigned char *arg);
 
415
typedef bool (Item::*Item_processor) (uchar *arg);
418
416
/*
419
417
  Analyzer function
420
418
    SYNOPSIS
422
420
                    OUT: Parameter to be passed to the transformer
423
421
 
424
422
    RETURN 
425
 
      true   Invoke the transformer
426
 
      false  Don't do it
 
423
      TRUE   Invoke the transformer
 
424
      FALSE  Don't do it
427
425
 
428
426
*/
429
 
typedef bool (Item::*Item_analyzer) (unsigned char **argp);
430
 
typedef Item* (Item::*Item_transformer) (unsigned char *arg);
 
427
typedef bool (Item::*Item_analyzer) (uchar **argp);
 
428
typedef Item* (Item::*Item_transformer) (uchar *arg);
431
429
typedef void (*Cond_traverser) (const Item *item, void *arg);
432
430
 
433
431
 
436
434
  Item(const Item &);                   /* Prevent use of these */
437
435
  void operator=(Item &);
438
436
  /* Cache of the result of is_expensive(). */
439
 
  int8_t is_expensive_cache;
440
 
  virtual bool is_expensive_processor(unsigned char *arg __attribute__((unused)))
 
437
  int8 is_expensive_cache;
 
438
  virtual bool is_expensive_processor(uchar *arg __attribute__((__unused__)))
441
439
  { return 0; }
442
440
 
443
441
public:
445
443
  { return sql_alloc(size); }
446
444
  static void *operator new(size_t size, MEM_ROOT *mem_root)
447
445
  { return alloc_root(mem_root, size); }
448
 
  static void operator delete(void *ptr __attribute__((unused)),
449
 
                              size_t size __attribute__((unused)))
 
446
  static void operator delete(void *ptr __attribute__((__unused__)),
 
447
                              size_t size __attribute__((__unused__)))
450
448
  { TRASH(ptr, size); }
451
 
  static void operator delete(void *ptr __attribute__((unused)),
452
 
                              MEM_ROOT *mem_root __attribute__((unused)))
 
449
  static void operator delete(void *ptr __attribute__((__unused__)),
 
450
                              MEM_ROOT *mem_root __attribute__((__unused__)))
453
451
  {}
454
452
 
455
453
  enum Type {FIELD_ITEM= 0, FUNC_ITEM, SUM_FUNC_ITEM, STRING_ITEM,
458
456
             PROC_ITEM,COND_ITEM, REF_ITEM, FIELD_STD_ITEM,
459
457
             FIELD_VARIANCE_ITEM, INSERT_VALUE_ITEM,
460
458
             SUBSELECT_ITEM, ROW_ITEM, CACHE_ITEM, TYPE_HOLDER,
461
 
             PARAM_ITEM, DECIMAL_ITEM,
 
459
             PARAM_ITEM, TRIGGER_FIELD_ITEM, DECIMAL_ITEM,
 
460
             XPATH_NODESET, XPATH_NODESET_CMP,
462
461
             VIEW_FIXER_ITEM};
463
462
 
464
463
  enum cond_result { COND_UNDEF,COND_OK,COND_TRUE,COND_FALSE };
466
465
  enum traverse_order { POSTFIX, PREFIX };
467
466
  
468
467
  /* Reuse size, only used by SP local variable assignment, otherwize 0 */
469
 
  uint32_t rsize;
 
468
  uint rsize;
470
469
 
471
470
  /*
472
471
    str_values's main purpose is to be used to cache the value in
477
476
  /* Original item name (if it was renamed)*/
478
477
  char * orig_name;
479
478
  Item *next;
480
 
  uint32_t max_length;
481
 
  uint32_t name_length;                     /* Length of name */
482
 
  int8_t marker;
483
 
  uint8_t decimals;
484
 
  bool maybe_null;                      /* If item may be null */
485
 
  bool null_value;                      /* if item is null */
486
 
  bool unsigned_flag;
487
 
  bool with_sum_func;
488
 
  bool fixed;                        /* If item fixed with fix_fields */
489
 
  bool is_autogenerated_name;        /* indicate was name of this Item
 
479
  uint32 max_length;
 
480
  uint name_length;                     /* Length of name */
 
481
  int8 marker;
 
482
  uint8 decimals;
 
483
  my_bool maybe_null;                   /* If item may be null */
 
484
  my_bool null_value;                   /* if item is null */
 
485
  my_bool unsigned_flag;
 
486
  my_bool with_sum_func;
 
487
  my_bool fixed;                        /* If item fixed with fix_fields */
 
488
  my_bool is_autogenerated_name;        /* indicate was name of this Item
490
489
                                           autogenerated or set by user */
491
490
  DTCollation collation;
492
 
  bool with_subselect;               /* If this item is a subselect or some
 
491
  my_bool with_subselect;               /* If this item is a subselect or some
493
492
                                           of its arguments is or contains a
494
493
                                           subselect. Computed by fix_fields. */
495
494
  Item_result cmp_context;              /* Comparison context */
510
509
    name=0;
511
510
#endif
512
511
  }             /*lint -e1509 */
513
 
  void set_name(const char *str, uint32_t length, const CHARSET_INFO * const cs);
 
512
  void set_name(const char *str, uint length, CHARSET_INFO *cs);
514
513
  void rename(char *new_name);
515
514
  void init_make_field(Send_field *tmp_field,enum enum_field_types type);
516
515
  virtual void cleanup();
517
516
  virtual void make_field(Send_field *field);
518
 
  Field *make_string_field(Table *table);
 
517
  Field *make_string_field(TABLE *table);
519
518
  virtual bool fix_fields(THD *, Item **);
520
519
  /*
521
520
    Fix after some tables has been pulled out. Basically re-calculate all
522
521
    attributes that are dependent on the tables.
523
522
  */
524
 
  virtual void fix_after_pullout(st_select_lex *new_parent __attribute__((unused)),
525
 
                                 Item **ref __attribute__((unused))) {};
 
523
  virtual void fix_after_pullout(st_select_lex *new_parent __attribute__((__unused__)),
 
524
                                 Item **ref __attribute__((__unused__))) {};
526
525
 
527
526
  /*
528
527
    should be used in case where we are sure that we do not need
557
556
 
558
557
    SYNOPSIS
559
558
      val_int_endpoint()
560
 
        left_endp  false  <=> The interval is "x < const" or "x <= const"
561
 
                   true   <=> The interval is "x > const" or "x >= const"
 
559
        left_endp  FALSE  <=> The interval is "x < const" or "x <= const"
 
560
                   TRUE   <=> The interval is "x > const" or "x >= const"
562
561
 
563
 
        incl_endp  IN   true <=> the comparison is '<' or '>'
564
 
                        false <=> the comparison is '<=' or '>='
 
562
        incl_endp  IN   TRUE <=> the comparison is '<' or '>'
 
563
                        FALSE <=> the comparison is '<=' or '>='
565
564
                   OUT  The same but for the "F(x) $CMP$ F(const)" comparison
566
565
 
567
566
    DESCRIPTION
583
582
    RETURN
584
583
      The output range bound, which equal to the value of val_int()
585
584
        - If the value of the function is NULL then the bound is the
586
 
          smallest possible value of INT64_MIN
 
585
          smallest possible value of LONGLONG_MIN
587
586
  */
588
 
  virtual int64_t val_int_endpoint(bool left_endp __attribute__((unused)),
589
 
                                    bool *incl_endp __attribute__((unused)))
 
587
  virtual longlong val_int_endpoint(bool left_endp __attribute__((__unused__)),
 
588
                                    bool *incl_endp __attribute__((__unused__)))
590
589
  { assert(0); return 0; }
591
590
 
592
591
 
598
597
      val_real()
599
598
 
600
599
    RETURN
601
 
      In case of NULL value return 0.0 and set null_value flag to true.
602
 
      If value is not null null_value flag will be reset to false.
 
600
      In case of NULL value return 0.0 and set null_value flag to TRUE.
 
601
      If value is not null null_value flag will be reset to FALSE.
603
602
  */
604
603
  virtual double val_real()=0;
605
604
  /*
609
608
      val_int()
610
609
 
611
610
    RETURN
612
 
      In case of NULL value return 0 and set null_value flag to true.
613
 
      If value is not null null_value flag will be reset to false.
 
611
      In case of NULL value return 0 and set null_value flag to TRUE.
 
612
      If value is not null null_value flag will be reset to FALSE.
614
613
  */
615
 
  virtual int64_t val_int()=0;
 
614
  virtual longlong val_int()=0;
616
615
  /*
617
616
    This is just a shortcut to avoid the cast. You should still use
618
617
    unsigned_flag to check the sign of the item.
619
618
  */
620
 
  inline uint64_t val_uint() { return (uint64_t) val_int(); }
 
619
  inline ulonglong val_uint() { return (ulonglong) val_int(); }
621
620
  /*
622
621
    Return string representation of this item object.
623
622
 
649
648
 
650
649
    RETURN
651
650
      In case of NULL value return 0 (NULL pointer) and set null_value flag
652
 
      to true.
653
 
      If value is not null null_value flag will be reset to false.
 
651
      to TRUE.
 
652
      If value is not null null_value flag will be reset to FALSE.
654
653
  */
655
654
  virtual String *val_str(String *str)=0;
656
655
  /*
667
666
 
668
667
    RETURN
669
668
      Return pointer on my_decimal (it can be other then passed via argument)
670
 
        if value is not NULL (null_value flag will be reset to false).
 
669
        if value is not NULL (null_value flag will be reset to FALSE).
671
670
      In case of NULL value it return 0 pointer and set null_value flag
672
 
        to true.
 
671
        to TRUE.
673
672
  */
674
673
  virtual my_decimal *val_decimal(my_decimal *decimal_buffer)= 0;
675
674
  /*
676
675
    Return boolean value of item.
677
676
 
678
677
    RETURN
679
 
      false value is false or NULL
680
 
      true value is true (not equal to 0)
 
678
      FALSE value is false or NULL
 
679
      TRUE value is true (not equal to 0)
681
680
  */
682
681
  virtual bool val_bool();
683
682
  virtual String *val_nodeset(String*) { return 0; }
690
689
  my_decimal *val_decimal_from_string(my_decimal *decimal_value);
691
690
  my_decimal *val_decimal_from_date(my_decimal *decimal_value);
692
691
  my_decimal *val_decimal_from_time(my_decimal *decimal_value);
693
 
  int64_t val_int_from_decimal();
 
692
  longlong val_int_from_decimal();
694
693
  double val_real_from_decimal();
695
694
 
696
695
  int save_time_in_field(Field *field);
699
698
 
700
699
  virtual Field *get_tmp_table_field(void) { return 0; }
701
700
  /* This is also used to create fields in CREATE ... SELECT: */
702
 
  virtual Field *tmp_table_field(Table *t_arg __attribute__((unused)))
 
701
  virtual Field *tmp_table_field(TABLE *t_arg __attribute__((__unused__)))
703
702
  { return 0; }
704
703
  virtual const char *full_name(void) const { return name ? name : "???"; }
705
704
 
710
709
    way as *val* methods do it.
711
710
  */
712
711
  virtual double  val_result() { return val_real(); }
713
 
  virtual int64_t val_int_result() { return val_int(); }
 
712
  virtual longlong val_int_result() { return val_int(); }
714
713
  virtual String *str_result(String* tmp) { return val_str(tmp); }
715
714
  virtual my_decimal *val_decimal_result(my_decimal *val)
716
715
  { return val_decimal(val); }
738
737
  /* cloning of constant items (0 if it is not const) */
739
738
  virtual Item *clone_item() { return 0; }
740
739
  virtual cond_result eq_cmp_result() const { return COND_OK; }
741
 
  inline uint32_t float_length(uint32_t decimals_par) const
 
740
  inline uint float_length(uint decimals_par) const
742
741
  { return decimals != NOT_FIXED_DEC ? (DBL_DIG+2+decimals_par) : DBL_DIG+8;}
743
 
  virtual uint32_t decimal_precision() const;
 
742
  virtual uint decimal_precision() const;
744
743
  inline int decimal_int_part() const
745
744
  { return my_decimal_int_part(decimal_precision(), decimals); }
746
745
  /* 
767
766
    mysql_register_view().
768
767
  */
769
768
  virtual inline void print(String *str,
770
 
                            enum_query_type query_type __attribute__((unused)))
 
769
                            enum_query_type query_type __attribute__((__unused__)))
771
770
  {
772
771
    str->append(full_name());
773
772
  }
774
773
 
775
774
  void print_item_w_name(String *, enum_query_type query_type);
776
775
  virtual void update_used_tables() {}
777
 
  virtual void split_sum_func(THD *thd __attribute__((unused)),
778
 
                              Item **ref_pointer_array __attribute__((unused)),
779
 
                              List<Item> &fields __attribute__((unused))) {}
 
776
  virtual void split_sum_func(THD *thd __attribute__((__unused__)),
 
777
                              Item **ref_pointer_array __attribute__((__unused__)),
 
778
                              List<Item> &fields __attribute__((__unused__))) {}
780
779
  /* Called for items that really have to be split */
781
780
  void split_sum_func2(THD *thd, Item **ref_pointer_array, List<Item> &fields,
782
781
                       Item **ref, bool skip_registered);
783
 
  virtual bool get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate);
784
 
  virtual bool get_time(DRIZZLE_TIME *ltime);
785
 
  virtual bool get_date_result(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
 
782
  virtual bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
 
783
  virtual bool get_time(MYSQL_TIME *ltime);
 
784
  virtual bool get_date_result(MYSQL_TIME *ltime,uint fuzzydate)
786
785
  { return get_date(ltime,fuzzydate); }
787
786
  /*
788
787
    The method allows to determine nullness of a complex expression 
800
799
 
801
800
  /*
802
801
    Inform the item that there will be no distinction between its result
803
 
    being false or NULL.
 
802
    being FALSE or NULL.
804
803
 
805
804
    NOTE
806
805
      This function will be called for eg. Items that are top-level AND-parts
813
812
    set field of temporary table for Item which can be switched on temporary
814
813
    table during query processing (grouping and so on)
815
814
  */
816
 
  virtual void set_result_field(Field *field __attribute__((unused))) {}
 
815
  virtual void set_result_field(Field *field __attribute__((__unused__))) {}
817
816
  virtual bool is_result_field(void) { return 0; }
818
817
  virtual bool is_bool_func(void) { return 0; }
819
 
  virtual void save_in_result_field(bool no_conversions __attribute__((unused)))
 
818
  virtual void save_in_result_field(bool no_conversions __attribute__((__unused__)))
820
819
  {}
821
820
  /*
822
821
    set value of aggregate function in case of no rows for grouping were found
823
822
  */
824
823
  virtual void no_rows_in_result(void) {}
825
 
  virtual Item *copy_or_same(THD *thd __attribute__((unused)))
 
824
  virtual Item *copy_or_same(THD *thd __attribute__((__unused__)))
826
825
  { return this; }
827
 
  virtual Item *copy_andor_structure(THD *thd  __attribute__((unused)))
 
826
  virtual Item *copy_andor_structure(THD *thd  __attribute__((__unused__)))
828
827
  { return this; }
829
828
  virtual Item *real_item(void) { return this; }
830
829
  virtual Item *get_tmp_table_item(THD *thd) { return copy_or_same(thd); }
831
830
 
832
 
  static const CHARSET_INFO *default_charset();
833
 
  virtual const CHARSET_INFO *compare_collation() { return NULL; }
 
831
  static CHARSET_INFO *default_charset();
 
832
  virtual CHARSET_INFO *compare_collation() { return NULL; }
834
833
 
835
 
  virtual bool walk(Item_processor processor __attribute__((unused)),
836
 
                    bool walk_subquery __attribute__((unused)),
837
 
                    unsigned char *arg)
 
834
  virtual bool walk(Item_processor processor __attribute__((__unused__)),
 
835
                    bool walk_subquery __attribute__((__unused__)),
 
836
                    uchar *arg)
838
837
  {
839
838
    return (this->*processor)(arg);
840
839
  }
841
840
 
842
 
  virtual Item* transform(Item_transformer transformer, unsigned char *arg);
 
841
  virtual Item* transform(Item_transformer transformer, uchar *arg);
843
842
 
844
843
  /*
845
844
    This function performs a generic "compilation" of the Item tree.
857
856
    i.e. analysis is performed top-down while transformation is done
858
857
    bottom-up.      
859
858
  */
860
 
  virtual Item* compile(Item_analyzer analyzer, unsigned char **arg_p,
861
 
                        Item_transformer transformer, unsigned char *arg_t)
 
859
  virtual Item* compile(Item_analyzer analyzer, uchar **arg_p,
 
860
                        Item_transformer transformer, uchar *arg_t)
862
861
  {
863
862
    if ((this->*analyzer) (arg_p))
864
863
      return ((this->*transformer) (arg_t));
865
864
    return 0;
866
865
  }
867
866
 
868
 
   virtual void traverse_cond(Cond_traverser traverser __attribute__((unused)),
 
867
   virtual void traverse_cond(Cond_traverser traverser __attribute__((__unused__)),
869
868
                              void *arg,
870
 
                              traverse_order order __attribute__((unused)))
 
869
                              traverse_order order __attribute__((__unused__)))
871
870
   {
872
871
     (*traverser)(this, arg);
873
872
   }
874
873
 
875
 
  virtual bool remove_dependence_processor(unsigned char * arg __attribute__((unused)))
 
874
  virtual bool remove_dependence_processor(uchar * arg __attribute__((__unused__)))
876
875
  { return 0; }
877
 
  virtual bool remove_fixed(unsigned char * arg __attribute__((unused)))
 
876
  virtual bool remove_fixed(uchar * arg __attribute__((__unused__)))
878
877
  {
879
878
    fixed= 0;
880
879
    return 0;
881
880
  }
882
 
  virtual bool cleanup_processor(unsigned char *arg __attribute__((unused)));
883
 
  virtual bool collect_item_field_processor(unsigned char * arg __attribute__((unused)))
 
881
  virtual bool cleanup_processor(uchar *arg __attribute__((__unused__)));
 
882
  virtual bool collect_item_field_processor(uchar * arg __attribute__((__unused__)))
884
883
  { return 0; }
885
 
  virtual bool find_item_in_field_list_processor(unsigned char *arg __attribute__((unused)))
 
884
  virtual bool find_item_in_field_list_processor(uchar *arg __attribute__((__unused__)))
886
885
 { return 0; }
887
 
  virtual bool change_context_processor(unsigned char *context __attribute__((unused)))
888
 
  { return 0; }
889
 
  virtual bool reset_query_id_processor(unsigned char *query_id_arg __attribute__((unused)))
890
 
  { return 0; }
891
 
  virtual bool register_field_in_read_map(unsigned char *arg __attribute__((unused)))
892
 
  { return 0; }
893
 
  /*
894
 
    The next function differs from the previous one that a bitmap to be updated
895
 
    is passed as unsigned char *arg.
896
 
  */
897
 
  virtual bool register_field_in_bitmap(unsigned char *arg __attribute__((unused)))
898
 
  { return 0; }
899
 
  virtual bool subst_argument_checker(unsigned char **arg)
 
886
  virtual bool change_context_processor(uchar *context __attribute__((__unused__)))
 
887
  { return 0; }
 
888
  virtual bool reset_query_id_processor(uchar *query_id_arg __attribute__((__unused__)))
 
889
  { return 0; }
 
890
  virtual bool register_field_in_read_map(uchar *arg __attribute__((__unused__)))
 
891
  { return 0; }
 
892
  virtual bool subst_argument_checker(uchar **arg)
900
893
  {
901
894
    if (*arg)
902
895
      *arg= NULL;
903
896
    return true;
904
897
  }
905
898
 
906
 
  /*
907
 
    Check if an expression/function is allowed for a virtual column
908
 
    SYNOPSIS
909
 
      check_vcol_func_processor()
910
 
      arg is just ignored
911
 
    RETURN VALUE
912
 
      TRUE                           Function not accepted
913
 
      FALSE                          Function accepted
914
 
  */
915
 
  virtual bool check_vcol_func_processor(unsigned char *arg __attribute__((unused))) 
916
 
  { return true; }
917
 
 
918
 
  virtual Item *equal_fields_propagator(unsigned char * arg __attribute__((unused))) { return this; }
919
 
  virtual bool set_no_const_sub(unsigned char *arg __attribute__((unused))) { return false; }
920
 
  virtual Item *replace_equal_field(unsigned char * arg __attribute__((unused))) { return this; }
921
 
 
 
899
  virtual Item *equal_fields_propagator(uchar * arg __attribute__((__unused__))) { return this; }
 
900
  virtual bool set_no_const_sub(uchar *arg __attribute__((__unused__))) { return false; }
 
901
  virtual Item *replace_equal_field(uchar * arg __attribute__((__unused__))) { return this; }
922
902
 
923
903
  /*
924
904
    For SP local variable returns pointer to Item representing its
931
911
    For SP local variable returns address of pointer to Item representing its
932
912
    current value and pointer passed via parameter otherwise.
933
913
  */
934
 
  virtual Item **this_item_addr(THD *thd __attribute__((unused)), Item **addr_arg) { return addr_arg; }
 
914
  virtual Item **this_item_addr(THD *thd __attribute__((__unused__)), Item **addr_arg) { return addr_arg; }
935
915
 
936
916
  // Row emulation
937
 
  virtual uint32_t cols() { return 1; }
938
 
  virtual Item* element_index(uint32_t i __attribute__((unused))) { return this; }
939
 
  virtual Item** addr(uint32_t i __attribute__((unused))) { return 0; }
940
 
  virtual bool check_cols(uint32_t c);
 
917
  virtual uint cols() { return 1; }
 
918
  virtual Item* element_index(uint i __attribute__((__unused__))) { return this; }
 
919
  virtual Item** addr(uint i __attribute__((__unused__))) { return 0; }
 
920
  virtual bool check_cols(uint c);
941
921
  // It is not row => null inside is impossible
942
922
  virtual bool null_inside() { return 0; }
943
923
  // used in row subselects to get value of elements
944
924
  virtual void bring_value() {}
945
925
 
946
 
  Field *tmp_table_field_from_field_type(Table *table, bool fixed_length);
 
926
  Field *tmp_table_field_from_field_type(TABLE *table, bool fixed_length);
947
927
  virtual Item_field *filed_for_view_update() { return 0; }
948
928
 
949
 
  virtual Item *neg_transformer(THD *thd __attribute__((unused))) { return NULL; }
950
 
  virtual Item *update_value_transformer(unsigned char *select_arg __attribute__((unused))) { return this; }
951
 
  virtual Item *safe_charset_converter(const CHARSET_INFO * const tocs);
 
929
  virtual Item *neg_transformer(THD *thd __attribute__((__unused__))) { return NULL; }
 
930
  virtual Item *update_value_transformer(uchar *select_arg __attribute__((__unused__))) { return this; }
 
931
  virtual Item *safe_charset_converter(CHARSET_INFO *tocs);
952
932
  void delete_self()
953
933
  {
954
934
    cleanup();
956
936
  }
957
937
 
958
938
  /*
959
 
    result_as_int64_t() must return true for Items representing DATE/TIME
 
939
    result_as_longlong() must return TRUE for Items representing DATE/TIME
960
940
    functions and DATE/TIME table fields.
961
941
    Those Items have result_type()==STRING_RESULT (and not INT_RESULT), but
962
942
    their values should be compared as integers (because the integer
963
943
    representation is more precise than the string one).
964
944
  */
965
 
  virtual bool result_as_int64_t() { return false; }
 
945
  virtual bool result_as_longlong() { return FALSE; }
966
946
  bool is_datetime();
967
947
 
968
948
  /*
979
959
  virtual bool is_expensive()
980
960
  {
981
961
    if (is_expensive_cache < 0)
982
 
      is_expensive_cache= walk(&Item::is_expensive_processor, 0, (unsigned char*)0);
 
962
      is_expensive_cache= walk(&Item::is_expensive_processor, 0, (uchar*)0);
983
963
    return test(is_expensive_cache);
984
964
  }
985
965
  String *check_well_formed_result(String *str, bool send_error= 0);
986
 
  bool eq_by_collation(Item *item, bool binary_cmp, const CHARSET_INFO * const cs); 
 
966
  bool eq_by_collation(Item *item, bool binary_cmp, CHARSET_INFO *cs); 
987
967
};
988
968
 
989
969
 
1004
984
};
1005
985
 
1006
986
bool agg_item_collations(DTCollation &c, const char *name,
1007
 
                         Item **items, uint32_t nitems, uint32_t flags, int item_sep);
 
987
                         Item **items, uint nitems, uint flags, int item_sep);
1008
988
bool agg_item_collations_for_comparison(DTCollation &c, const char *name,
1009
 
                                        Item **items, uint32_t nitems, uint32_t flags);
 
989
                                        Item **items, uint nitems, uint flags);
1010
990
bool agg_item_charsets(DTCollation &c, const char *name,
1011
 
                       Item **items, uint32_t nitems, uint32_t flags, int item_sep);
 
991
                       Item **items, uint nitems, uint flags, int item_sep);
1012
992
 
1013
993
 
1014
994
class Item_num: public Item_basic_constant
1016
996
public:
1017
997
  Item_num() {}                               /* Remove gcc warning */
1018
998
  virtual Item_num *neg()= 0;
1019
 
  Item *safe_charset_converter(const CHARSET_INFO * const tocs);
 
999
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1020
1000
};
1021
1001
 
1022
1002
#define NO_CACHED_FIELD_INDEX ((uint)(-1))
1046
1026
    stmts for speeding up their re-execution. Holds NO_CACHED_FIELD_INDEX 
1047
1027
    if index value is not known.
1048
1028
  */
1049
 
  uint32_t cached_field_index;
 
1029
  uint cached_field_index;
1050
1030
  /*
1051
1031
    Cached pointer to table which contains this field, used for the same reason
1052
1032
    by prep. stmt. too in case then we have not-fully qualified field.
1053
1033
    0 - means no cached value.
1054
1034
  */
1055
 
  TableList *cached_table;
 
1035
  TABLE_LIST *cached_table;
1056
1036
  st_select_lex *depended_from;
1057
1037
  Item_ident(Name_resolution_context *context_arg,
1058
1038
             const char *db_name_arg, const char *table_name_arg,
1060
1040
  Item_ident(THD *thd, Item_ident *item);
1061
1041
  const char *full_name() const;
1062
1042
  void cleanup();
1063
 
  bool remove_dependence_processor(unsigned char * arg);
 
1043
  bool remove_dependence_processor(uchar * arg);
1064
1044
  virtual void print(String *str, enum_query_type query_type);
1065
 
  virtual bool change_context_processor(unsigned char *cntx)
1066
 
    { context= (Name_resolution_context *)cntx; return false; }
 
1045
  virtual bool change_context_processor(uchar *cntx)
 
1046
    { context= (Name_resolution_context *)cntx; return FALSE; }
1067
1047
  friend bool insert_fields(THD *thd, Name_resolution_context *context,
1068
1048
                            const char *db_name,
1069
1049
                            const char *table_name, List_iterator<Item> *it,
1085
1065
 
1086
1066
  enum Type type() const { return FIELD_ITEM; }
1087
1067
  double val_real() { return field->val_real(); }
1088
 
  int64_t val_int() { return field->val_int(); }
 
1068
  longlong val_int() { return field->val_int(); }
1089
1069
  String *val_str(String *str) { return field->val_str(str); }
1090
1070
  my_decimal *val_decimal(my_decimal *dec) { return field->val_decimal(dec); }
1091
1071
  void make_field(Send_field *tmp_field);
1104
1084
  Item_equal *item_equal;
1105
1085
  bool no_const_subst;
1106
1086
  /*
1107
 
    if any_privileges set to true then here real effective privileges will
 
1087
    if any_privileges set to TRUE then here real effective privileges will
1108
1088
    be stored
1109
1089
  */
1110
 
  uint32_t have_privileges;
 
1090
  uint have_privileges;
1111
1091
  /* field need any privileges (for VIEW creation) */
1112
1092
  bool any_privileges;
1113
1093
  Item_field(Name_resolution_context *context_arg,
1132
1112
  enum Type type() const { return FIELD_ITEM; }
1133
1113
  bool eq(const Item *item, bool binary_cmp) const;
1134
1114
  double val_real();
1135
 
  int64_t val_int();
 
1115
  longlong val_int();
1136
1116
  my_decimal *val_decimal(my_decimal *);
1137
1117
  String *val_str(String*);
1138
1118
  double val_result();
1139
 
  int64_t val_int_result();
 
1119
  longlong val_int_result();
1140
1120
  String *str_result(String* tmp);
1141
1121
  my_decimal *val_decimal_result(my_decimal *);
1142
1122
  bool val_bool_result();
1164
1144
  {
1165
1145
    return MONOTONIC_STRICT_INCREASING;
1166
1146
  }
1167
 
  int64_t val_int_endpoint(bool left_endp, bool *incl_endp);
 
1147
  longlong val_int_endpoint(bool left_endp, bool *incl_endp);
1168
1148
  Field *get_tmp_table_field() { return result_field; }
1169
 
  Field *tmp_table_field(Table *t_arg __attribute__((unused))) { return result_field; }
1170
 
  bool get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate);
1171
 
  bool get_date_result(DRIZZLE_TIME *ltime,uint32_t fuzzydate);
1172
 
  bool get_time(DRIZZLE_TIME *ltime);
 
1149
  Field *tmp_table_field(TABLE *t_arg __attribute__((__unused__))) { return result_field; }
 
1150
  bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
 
1151
  bool get_date_result(MYSQL_TIME *ltime,uint fuzzydate);
 
1152
  bool get_time(MYSQL_TIME *ltime);
1173
1153
  bool is_null() { return field->is_null(); }
1174
1154
  void update_null_value();
1175
1155
  Item *get_tmp_table_item(THD *thd);
1176
 
  bool collect_item_field_processor(unsigned char * arg);
1177
 
  bool find_item_in_field_list_processor(unsigned char *arg);
1178
 
  bool register_field_in_read_map(unsigned char *arg);
1179
 
  bool register_field_in_bitmap(unsigned char *arg);
1180
 
  bool check_vcol_func_processor(unsigned char *arg __attribute__((unused)))
1181
 
  { return false; }
 
1156
  bool collect_item_field_processor(uchar * arg);
 
1157
  bool find_item_in_field_list_processor(uchar *arg);
 
1158
  bool register_field_in_read_map(uchar *arg);
1182
1159
  void cleanup();
1183
 
  bool result_as_int64_t()
 
1160
  bool result_as_longlong()
1184
1161
  {
1185
 
    return field->can_be_compared_as_int64_t();
 
1162
    return field->can_be_compared_as_longlong();
1186
1163
  }
1187
1164
  Item_equal *find_item_equal(COND_EQUAL *cond_equal);
1188
 
  bool subst_argument_checker(unsigned char **arg);
1189
 
  Item *equal_fields_propagator(unsigned char *arg);
1190
 
  bool set_no_const_sub(unsigned char *arg);
1191
 
  Item *replace_equal_field(unsigned char *arg);
1192
 
  inline uint32_t max_disp_length() { return field->max_display_length(); }
 
1165
  bool subst_argument_checker(uchar **arg);
 
1166
  Item *equal_fields_propagator(uchar *arg);
 
1167
  bool set_no_const_sub(uchar *arg);
 
1168
  Item *replace_equal_field(uchar *arg);
 
1169
  inline uint32 max_disp_length() { return field->max_display_length(); }
1193
1170
  Item_field *filed_for_view_update() { return this; }
1194
 
  Item *safe_charset_converter(const CHARSET_INFO * const tocs);
 
1171
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1195
1172
  int fix_outer_field(THD *thd, Field **field, Item **reference);
1196
 
  virtual Item *update_value_transformer(unsigned char *select_arg);
 
1173
  virtual Item *update_value_transformer(uchar *select_arg);
1197
1174
  virtual void print(String *str, enum_query_type query_type);
1198
1175
 
1199
1176
  friend class Item_default_value;
1206
1183
public:
1207
1184
  Item_null(char *name_par=0)
1208
1185
  {
1209
 
    maybe_null= null_value= true;
 
1186
    maybe_null= null_value= TRUE;
1210
1187
    max_length= 0;
1211
1188
    name= name_par ? name_par : (char*) "NULL";
1212
1189
    fixed= 1;
1215
1192
  enum Type type() const { return NULL_ITEM; }
1216
1193
  bool eq(const Item *item, bool binary_cmp) const;
1217
1194
  double val_real();
1218
 
  int64_t val_int();
 
1195
  longlong val_int();
1219
1196
  String *val_str(String *str);
1220
1197
  my_decimal *val_decimal(my_decimal *);
1221
1198
  int save_in_field(Field *field, bool no_conversions);
1222
1199
  int save_safe_in_field(Field *field);
1223
1200
  bool send(Protocol *protocol, String *str);
1224
1201
  enum Item_result result_type () const { return STRING_RESULT; }
1225
 
  enum_field_types field_type() const   { return DRIZZLE_TYPE_NULL; }
 
1202
  enum_field_types field_type() const   { return MYSQL_TYPE_NULL; }
1226
1203
  bool basic_const_item() const { return 1; }
1227
1204
  Item *clone_item() { return new Item_null(name); }
1228
1205
  bool is_null() { return 1; }
1229
1206
 
1230
1207
  virtual inline void print(String *str,
1231
 
                            enum_query_type query_type __attribute__((unused)))
 
1208
                            enum_query_type query_type __attribute__((__unused__)))
1232
1209
  {
1233
1210
    str->append(STRING_WITH_LEN("NULL"));
1234
1211
  }
1235
1212
 
1236
 
  Item *safe_charset_converter(const CHARSET_INFO * const tocs);
1237
 
  bool check_vcol_func_processor(unsigned char *arg __attribute__((unused)))
1238
 
  { return false; }
 
1213
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1239
1214
};
1240
1215
 
1241
1216
class Item_null_result :public Item_null
1248
1223
  {
1249
1224
    save_in_field(result_field, no_conversions);
1250
1225
  }
1251
 
  bool check_vcol_func_processor(unsigned char *arg __attribute__((unused)))
1252
 
  { return true; }
1253
1226
};  
1254
1227
 
1255
1228
/* Item represents one placeholder ('?') of prepared statement */
1282
1255
  my_decimal decimal_value;
1283
1256
  union
1284
1257
  {
1285
 
    int64_t integer;
 
1258
    longlong integer;
1286
1259
    double   real;
1287
1260
    /*
1288
1261
      Character sets conversion info for string values.
1292
1265
    */
1293
1266
    struct CONVERSION_INFO
1294
1267
    {
1295
 
      const CHARSET_INFO *character_set_client;
1296
 
      const CHARSET_INFO *character_set_of_placeholder;
 
1268
      CHARSET_INFO *character_set_client;
 
1269
      CHARSET_INFO *character_set_of_placeholder;
1297
1270
      /*
1298
1271
        This points at character set of connection if conversion
1299
1272
        to it is required (i. e. if placeholder typecode is not BLOB).
1300
1273
        Otherwise it's equal to character_set_client (to simplify
1301
1274
        check in convert_str_value()).
1302
1275
      */
1303
 
      const CHARSET_INFO *final_character_set_of_str_value;
 
1276
      CHARSET_INFO *final_character_set_of_str_value;
1304
1277
    } cs_info;
1305
 
    DRIZZLE_TIME     time;
 
1278
    MYSQL_TIME     time;
1306
1279
  } value;
1307
1280
 
1308
1281
  /* Cached values for virtual methods to save us one switch.  */
1313
1286
    Used when this item is used in a temporary table.
1314
1287
    This is NOT placeholder metadata sent to client, as this value
1315
1288
    is assigned after sending metadata (in setup_one_conversion_function).
1316
 
    For example in case of 'SELECT ?' you'll get DRIZZLE_TYPE_STRING both
 
1289
    For example in case of 'SELECT ?' you'll get MYSQL_TYPE_STRING both
1317
1290
    in result set and placeholders metadata, no matter what type you will
1318
1291
    supply for this placeholder in mysql_stmt_execute.
1319
1292
  */
1322
1295
    Offset of placeholder inside statement text. Used to create
1323
1296
    no-placeholders version of this statement for the binary log.
1324
1297
  */
1325
 
  uint32_t pos_in_query;
 
1298
  uint pos_in_query;
1326
1299
 
1327
 
  Item_param(uint32_t pos_in_query_arg);
 
1300
  Item_param(uint pos_in_query_arg);
1328
1301
 
1329
1302
  enum Item_result result_type () const { return item_result_type; }
1330
1303
  enum Type type() const { return item_type; }
1331
1304
  enum_field_types field_type() const { return param_type; }
1332
1305
 
1333
1306
  double val_real();
1334
 
  int64_t val_int();
 
1307
  longlong val_int();
1335
1308
  my_decimal *val_decimal(my_decimal*);
1336
1309
  String *val_str(String*);
1337
 
  bool get_time(DRIZZLE_TIME *tm);
1338
 
  bool get_date(DRIZZLE_TIME *tm, uint32_t fuzzydate);
 
1310
  bool get_time(MYSQL_TIME *tm);
 
1311
  bool get_date(MYSQL_TIME *tm, uint fuzzydate);
1339
1312
  int  save_in_field(Field *field, bool no_conversions);
1340
1313
 
1341
1314
  void set_null();
1342
 
  void set_int(int64_t i, uint32_t max_length_arg);
 
1315
  void set_int(longlong i, uint32 max_length_arg);
1343
1316
  void set_double(double i);
1344
 
  void set_decimal(char *str, ulong length);
 
1317
  void set_decimal(const char *str, ulong length);
1345
1318
  bool set_str(const char *str, ulong length);
1346
1319
  bool set_longdata(const char *str, ulong length);
1347
 
  void set_time(DRIZZLE_TIME *tm, enum enum_drizzle_timestamp_type type,
1348
 
                uint32_t max_length_arg);
 
1320
  void set_time(MYSQL_TIME *tm, timestamp_type type, uint32 max_length_arg);
1349
1321
  bool set_from_user_var(THD *thd, const user_var_entry *entry);
1350
1322
  void reset();
1351
1323
  /*
1354
1326
    don't need to check that packet is not broken there). See
1355
1327
    sql_prepare.cc for details.
1356
1328
  */
1357
 
  void (*set_param_func)(Item_param *param, unsigned char **pos, ulong len);
 
1329
  void (*set_param_func)(Item_param *param, uchar **pos, ulong len);
1358
1330
 
1359
1331
  const String *query_val_str(String *str) const;
1360
1332
 
1379
1351
    words, avoid pointing at one item from two different nodes of the tree.
1380
1352
    Return a new basic constant item if parameter value is a basic
1381
1353
    constant, assert otherwise. This method is called only if
1382
 
    basic_const_item returned true.
 
1354
    basic_const_item returned TRUE.
1383
1355
  */
1384
 
  Item *safe_charset_converter(const CHARSET_INFO * const tocs);
 
1356
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1385
1357
  Item *clone_item();
1386
1358
  /*
1387
1359
    Implement by-value equality evaluation if parameter value
1388
1360
    is set and is a basic constant (integer, real or string).
1389
 
    Otherwise return false.
 
1361
    Otherwise return FALSE.
1390
1362
  */
1391
1363
  bool eq(const Item *item, bool binary_cmp) const;
1392
1364
  /** Item is a argument to a limit clause. */
1397
1369
class Item_int :public Item_num
1398
1370
{
1399
1371
public:
1400
 
  int64_t value;
1401
 
  Item_int(int32_t i,uint32_t length= MY_INT32_NUM_DECIMAL_DIGITS)
1402
 
    :value((int64_t) i)
 
1372
  longlong value;
 
1373
  Item_int(int32 i,uint length= MY_INT32_NUM_DECIMAL_DIGITS)
 
1374
    :value((longlong) i)
1403
1375
    { max_length=length; fixed= 1; }
1404
 
  Item_int(int64_t i,uint32_t length= MY_INT64_NUM_DECIMAL_DIGITS)
 
1376
  Item_int(longlong i,uint length= MY_INT64_NUM_DECIMAL_DIGITS)
1405
1377
    :value(i)
1406
1378
    { max_length=length; fixed= 1; }
1407
 
  Item_int(uint64_t i, uint32_t length= MY_INT64_NUM_DECIMAL_DIGITS)
1408
 
    :value((int64_t)i)
 
1379
  Item_int(ulonglong i, uint length= MY_INT64_NUM_DECIMAL_DIGITS)
 
1380
    :value((longlong)i)
1409
1381
    { max_length=length; fixed= 1; unsigned_flag= 1; }
1410
 
  Item_int(const char *str_arg,int64_t i,uint32_t length) :value(i)
 
1382
  Item_int(const char *str_arg,longlong i,uint length) :value(i)
1411
1383
    { max_length=length; name=(char*) str_arg; fixed= 1; }
1412
 
  Item_int(const char *str_arg, uint32_t length=64);
 
1384
  Item_int(const char *str_arg, uint length=64);
1413
1385
  enum Type type() const { return INT_ITEM; }
1414
1386
  enum Item_result result_type () const { return INT_RESULT; }
1415
 
  enum_field_types field_type() const { return DRIZZLE_TYPE_LONGLONG; }
1416
 
  int64_t val_int() { assert(fixed == 1); return value; }
 
1387
  enum_field_types field_type() const { return MYSQL_TYPE_LONGLONG; }
 
1388
  longlong val_int() { assert(fixed == 1); return value; }
1417
1389
  double val_real() { assert(fixed == 1); return (double) value; }
1418
1390
  my_decimal *val_decimal(my_decimal *);
1419
1391
  String *val_str(String*);
1422
1394
  Item *clone_item() { return new Item_int(name,value,max_length); }
1423
1395
  virtual void print(String *str, enum_query_type query_type);
1424
1396
  Item_num *neg() { value= -value; return this; }
1425
 
  uint32_t decimal_precision() const
 
1397
  uint decimal_precision() const
1426
1398
  { return (uint)(max_length - test(value < 0)); }
1427
1399
  bool eq(const Item *, bool binary_cmp) const;
1428
 
  bool check_vcol_func_processor(unsigned char *arg __attribute__((unused)))
1429
 
  { return false; }
1430
1400
};
1431
1401
 
1432
1402
 
1433
1403
class Item_uint :public Item_int
1434
1404
{
1435
1405
public:
1436
 
  Item_uint(const char *str_arg, uint32_t length);
1437
 
  Item_uint(uint64_t i) :Item_int((uint64_t) i, 10) {}
1438
 
  Item_uint(const char *str_arg, int64_t i, uint32_t length);
 
1406
  Item_uint(const char *str_arg, uint length);
 
1407
  Item_uint(ulonglong i) :Item_int((ulonglong) i, 10) {}
 
1408
  Item_uint(const char *str_arg, longlong i, uint length);
1439
1409
  double val_real()
1440
 
    { assert(fixed == 1); return uint64_t2double((uint64_t)value); }
 
1410
    { assert(fixed == 1); return ulonglong2double((ulonglong)value); }
1441
1411
  String *val_str(String*);
1442
1412
  Item *clone_item() { return new Item_uint(name, value, max_length); }
1443
1413
  int save_in_field(Field *field, bool no_conversions);
1444
1414
  virtual void print(String *str, enum_query_type query_type);
1445
1415
  Item_num *neg ();
1446
 
  uint32_t decimal_precision() const { return max_length; }
1447
 
  bool check_vcol_func_processor(unsigned char *arg __attribute__((unused)))
1448
 
  { return false; }
 
1416
  uint decimal_precision() const { return max_length; }
1449
1417
};
1450
1418
 
1451
1419
 
1455
1423
protected:
1456
1424
  my_decimal decimal_value;
1457
1425
public:
1458
 
  Item_decimal(const char *str_arg, uint32_t length, const CHARSET_INFO * const charset);
 
1426
  Item_decimal(const char *str_arg, uint length, CHARSET_INFO *charset);
1459
1427
  Item_decimal(const char *str, const my_decimal *val_arg,
1460
 
               uint32_t decimal_par, uint32_t length);
 
1428
               uint decimal_par, uint length);
1461
1429
  Item_decimal(my_decimal *value_par);
1462
 
  Item_decimal(int64_t val, bool unsig);
 
1430
  Item_decimal(longlong val, bool unsig);
1463
1431
  Item_decimal(double val, int precision, int scale);
1464
 
  Item_decimal(const unsigned char *bin, int precision, int scale);
 
1432
  Item_decimal(const uchar *bin, int precision, int scale);
1465
1433
 
1466
1434
  enum Type type() const { return DECIMAL_ITEM; }
1467
1435
  enum Item_result result_type () const { return DECIMAL_RESULT; }
1468
 
  enum_field_types field_type() const { return DRIZZLE_TYPE_NEWDECIMAL; }
1469
 
  int64_t val_int();
 
1436
  enum_field_types field_type() const { return MYSQL_TYPE_NEWDECIMAL; }
 
1437
  longlong val_int();
1470
1438
  double val_real();
1471
1439
  String *val_str(String*);
1472
 
  my_decimal *val_decimal(my_decimal *val __attribute__((unused)))
 
1440
  my_decimal *val_decimal(my_decimal *val __attribute__((__unused__)))
1473
1441
  { return &decimal_value; }
1474
1442
  int save_in_field(Field *field, bool no_conversions);
1475
1443
  bool basic_const_item() const { return 1; }
1484
1452
    unsigned_flag= !decimal_value.sign();
1485
1453
    return this;
1486
1454
  }
1487
 
  uint32_t decimal_precision() const { return decimal_value.precision(); }
 
1455
  uint decimal_precision() const { return decimal_value.precision(); }
1488
1456
  bool eq(const Item *, bool binary_cmp) const;
1489
1457
  void set_decimal_value(my_decimal *value_par);
1490
 
  bool check_vcol_func_processor(unsigned char *arg __attribute__((unused)))
1491
 
  { return false; }
1492
1458
};
1493
1459
 
1494
1460
 
1498
1464
public:
1499
1465
  double value;
1500
1466
  // Item_real() :value(0) {}
1501
 
  Item_float(const char *str_arg, uint32_t length);
1502
 
  Item_float(const char *str,double val_arg,uint32_t decimal_par,uint32_t length)
 
1467
  Item_float(const char *str_arg, uint length);
 
1468
  Item_float(const char *str,double val_arg,uint decimal_par,uint length)
1503
1469
    :value(val_arg)
1504
1470
  {
1505
1471
    presentation= name=(char*) str;
1506
 
    decimals=(uint8_t) decimal_par;
 
1472
    decimals=(uint8) decimal_par;
1507
1473
    max_length=length;
1508
1474
    fixed= 1;
1509
1475
  }
1510
 
  Item_float(double value_par, uint32_t decimal_par) :presentation(0), value(value_par)
 
1476
  Item_float(double value_par, uint decimal_par) :presentation(0), value(value_par)
1511
1477
  {
1512
 
    decimals= (uint8_t) decimal_par;
 
1478
    decimals= (uint8) decimal_par;
1513
1479
    fixed= 1;
1514
1480
  }
1515
1481
  int save_in_field(Field *field, bool no_conversions);
1516
1482
  enum Type type() const { return REAL_ITEM; }
1517
 
  enum_field_types field_type() const { return DRIZZLE_TYPE_DOUBLE; }
 
1483
  enum_field_types field_type() const { return MYSQL_TYPE_DOUBLE; }
1518
1484
  double val_real() { assert(fixed == 1); return value; }
1519
 
  int64_t val_int()
 
1485
  longlong val_int()
1520
1486
  {
1521
1487
    assert(fixed == 1);
1522
 
    if (value <= (double) INT64_MIN)
1523
 
    {
1524
 
       return INT64_MIN;
1525
 
    }
1526
 
    else if (value >= (double) (uint64_t) INT64_MAX)
1527
 
    {
1528
 
      return INT64_MAX;
1529
 
    }
1530
 
    return (int64_t) rint(value);
 
1488
    if (value <= (double) LONGLONG_MIN)
 
1489
    {
 
1490
       return LONGLONG_MIN;
 
1491
    }
 
1492
    else if (value >= (double) (ulonglong) LONGLONG_MAX)
 
1493
    {
 
1494
      return LONGLONG_MAX;
 
1495
    }
 
1496
    return (longlong) rint(value);
1531
1497
  }
1532
1498
  String *val_str(String*);
1533
1499
  my_decimal *val_decimal(my_decimal *);
1544
1510
{
1545
1511
  const char *func_name;
1546
1512
public:
1547
 
  Item_static_float_func(const char *str, double val_arg, uint32_t decimal_par,
1548
 
                        uint32_t length)
1549
 
    :Item_float(NULL, val_arg, decimal_par, length), func_name(str)
 
1513
  Item_static_float_func(const char *str, double val_arg, uint decimal_par,
 
1514
                        uint length)
 
1515
    :Item_float(NullS, val_arg, decimal_par, length), func_name(str)
1550
1516
  {}
1551
1517
 
1552
1518
  virtual inline void print(String *str,
1553
 
                            enum_query_type query_type __attribute__((unused)))
 
1519
                            enum_query_type query_type __attribute__((__unused__)))
1554
1520
  {
1555
1521
    str->append(func_name);
1556
1522
  }
1557
1523
 
1558
 
  Item *safe_charset_converter(const CHARSET_INFO * const tocs);
1559
 
  bool check_vcol_func_processor(unsigned char *arg __attribute__((unused)))
1560
 
  { return false; }
 
1524
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1561
1525
};
1562
1526
 
1563
1527
 
1564
1528
class Item_string :public Item_basic_constant
1565
1529
{
1566
1530
public:
1567
 
  Item_string(const char *str,uint32_t length,
1568
 
              const CHARSET_INFO * const cs, Derivation dv= DERIVATION_COERCIBLE,
1569
 
              uint32_t repertoire= MY_REPERTOIRE_UNICODE30)
1570
 
    : m_cs_specified(false)
 
1531
  Item_string(const char *str,uint length,
 
1532
              CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE,
 
1533
              uint repertoire= MY_REPERTOIRE_UNICODE30)
 
1534
    : m_cs_specified(FALSE)
1571
1535
  {
1572
1536
    str_value.set_or_copy_aligned(str, length, cs);
1573
1537
    collation.set(cs, dv, repertoire);
1585
1549
    fixed= 1;
1586
1550
  }
1587
1551
  /* Just create an item and do not fill string representation */
1588
 
  Item_string(const CHARSET_INFO * const cs, Derivation dv= DERIVATION_COERCIBLE)
1589
 
    : m_cs_specified(false)
 
1552
  Item_string(CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE)
 
1553
    : m_cs_specified(FALSE)
1590
1554
  {
1591
1555
    collation.set(cs, dv);
1592
1556
    max_length= 0;
1594
1558
    decimals= NOT_FIXED_DEC;
1595
1559
    fixed= 1;
1596
1560
  }
1597
 
  Item_string(const char *name_par, const char *str, uint32_t length,
1598
 
              const CHARSET_INFO * const cs, Derivation dv= DERIVATION_COERCIBLE,
1599
 
              uint32_t repertoire= MY_REPERTOIRE_UNICODE30)
1600
 
    : m_cs_specified(false)
 
1561
  Item_string(const char *name_par, const char *str, uint length,
 
1562
              CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE,
 
1563
              uint repertoire= MY_REPERTOIRE_UNICODE30)
 
1564
    : m_cs_specified(FALSE)
1601
1565
  {
1602
1566
    str_value.set_or_copy_aligned(str, length, cs);
1603
1567
    collation.set(cs, dv, repertoire);
1611
1575
    This is used in stored procedures to avoid memory leaks and
1612
1576
    does a deep copy of its argument.
1613
1577
  */
1614
 
  void set_str_with_copy(const char *str_arg, uint32_t length_arg)
 
1578
  void set_str_with_copy(const char *str_arg, uint length_arg)
1615
1579
  {
1616
1580
    str_value.copy(str_arg, length_arg, collation.collation);
1617
1581
    max_length= str_value.numchars() * collation.collation->mbmaxlen;
1624
1588
  }
1625
1589
  enum Type type() const { return STRING_ITEM; }
1626
1590
  double val_real();
1627
 
  int64_t val_int();
 
1591
  longlong val_int();
1628
1592
  String *val_str(String*)
1629
1593
  {
1630
1594
    assert(fixed == 1);
1633
1597
  my_decimal *val_decimal(my_decimal *);
1634
1598
  int save_in_field(Field *field, bool no_conversions);
1635
1599
  enum Item_result result_type () const { return STRING_RESULT; }
1636
 
  enum_field_types field_type() const { return DRIZZLE_TYPE_VARCHAR; }
 
1600
  enum_field_types field_type() const { return MYSQL_TYPE_VARCHAR; }
1637
1601
  bool basic_const_item() const { return 1; }
1638
1602
  bool eq(const Item *item, bool binary_cmp) const;
1639
1603
  Item *clone_item() 
1641
1605
    return new Item_string(name, str_value.ptr(), 
1642
1606
                           str_value.length(), collation.collation);
1643
1607
  }
1644
 
  Item *safe_charset_converter(const CHARSET_INFO * const tocs);
1645
 
  inline void append(char *str, uint32_t length)
 
1608
  Item *safe_charset_converter(CHARSET_INFO *tocs);
 
1609
  inline void append(char *str, uint length)
1646
1610
  {
1647
1611
    str_value.append(str, length);
1648
1612
    max_length= str_value.numchars() * collation.collation->mbmaxlen;
1650
1614
  virtual void print(String *str, enum_query_type query_type);
1651
1615
 
1652
1616
  /**
1653
 
    Return true if character-set-introducer was explicitly specified in the
 
1617
    Return TRUE if character-set-introducer was explicitly specified in the
1654
1618
    original query for this item (text literal).
1655
1619
 
1656
1620
    This operation is to be called from Item_string::print(). The idea is
1664
1628
    one day when we start using original query as a view definition.
1665
1629
 
1666
1630
    @return This operation returns the value of m_cs_specified attribute.
1667
 
      @retval true if character set introducer was explicitly specified in
 
1631
      @retval TRUE if character set introducer was explicitly specified in
1668
1632
      the original query.
1669
 
      @retval false otherwise.
 
1633
      @retval FALSE otherwise.
1670
1634
  */
1671
1635
  inline bool is_cs_specified() const
1672
1636
  {
1687
1651
  {
1688
1652
    m_cs_specified= cs_specified;
1689
1653
  }
1690
 
  bool check_vcol_func_processor(unsigned char *arg __attribute__((unused)))
1691
 
  { return false; }
1692
1654
 
1693
1655
private:
1694
1656
  bool m_cs_specified;
1699
1661
{
1700
1662
  const char *func_name;
1701
1663
public:
1702
 
  Item_static_string_func(const char *name_par, const char *str, uint32_t length,
1703
 
                          const CHARSET_INFO * const cs,
 
1664
  Item_static_string_func(const char *name_par, const char *str, uint length,
 
1665
                          CHARSET_INFO *cs,
1704
1666
                          Derivation dv= DERIVATION_COERCIBLE)
1705
 
    :Item_string(NULL, str, length, cs, dv), func_name(name_par)
 
1667
    :Item_string(NullS, str, length, cs, dv), func_name(name_par)
1706
1668
  {}
1707
 
  Item *safe_charset_converter(const CHARSET_INFO * const tocs);
 
1669
  Item *safe_charset_converter(CHARSET_INFO *tocs);
1708
1670
 
1709
1671
  virtual inline void print(String *str,
1710
 
                            enum_query_type query_type __attribute__((unused)))
 
1672
                            enum_query_type query_type __attribute__((__unused__)))
1711
1673
  {
1712
1674
    str->append(func_name);
1713
1675
  }
1714
 
  bool check_vcol_func_processor(unsigned char *arg __attribute__((unused)))
1715
 
  { return true; }
1716
1676
};
1717
1677
 
1718
1678
 
1732
1692
class Item_blob :public Item_string
1733
1693
{
1734
1694
public:
1735
 
  Item_blob(const char *name, uint32_t length) :
 
1695
  Item_blob(const char *name, uint length) :
1736
1696
    Item_string(name, length, &my_charset_bin)
1737
1697
  { max_length= length; }
1738
1698
  enum Type type() const { return TYPE_HOLDER; }
1739
 
  enum_field_types field_type() const { return DRIZZLE_TYPE_BLOB; }
 
1699
  enum_field_types field_type() const { return MYSQL_TYPE_BLOB; }
1740
1700
};
1741
1701
 
1742
1702
 
1749
1709
class Item_empty_string :public Item_string
1750
1710
{
1751
1711
public:
1752
 
  Item_empty_string(const char *header,uint32_t length, const CHARSET_INFO * cs= NULL) :
 
1712
  Item_empty_string(const char *header,uint length, CHARSET_INFO *cs= NULL) :
1753
1713
    Item_string("",0, cs ? cs : &my_charset_utf8_general_ci)
1754
1714
    { name=(char*) header; max_length= cs ? length * cs->mbmaxlen : length; }
1755
1715
  void make_field(Send_field *field);
1760
1720
{
1761
1721
  enum_field_types int_field_type;
1762
1722
public:
1763
 
  Item_return_int(const char *name_arg, uint32_t length,
1764
 
                  enum_field_types field_type_arg, int64_t value= 0)
 
1723
  Item_return_int(const char *name_arg, uint length,
 
1724
                  enum_field_types field_type_arg, longlong value= 0)
1765
1725
    :Item_int(name_arg, value, length), int_field_type(field_type_arg)
1766
1726
  {
1767
1727
    unsigned_flag=1;
1774
1734
{
1775
1735
public:
1776
1736
  Item_hex_string() {}
1777
 
  Item_hex_string(const char *str,uint32_t str_length);
 
1737
  Item_hex_string(const char *str,uint str_length);
1778
1738
  enum Type type() const { return VARBIN_ITEM; }
1779
1739
  double val_real()
1780
1740
  { 
1781
1741
    assert(fixed == 1); 
1782
 
    return (double) (uint64_t) Item_hex_string::val_int();
 
1742
    return (double) (ulonglong) Item_hex_string::val_int();
1783
1743
  }
1784
 
  int64_t val_int();
 
1744
  longlong val_int();
1785
1745
  bool basic_const_item() const { return 1; }
1786
1746
  String *val_str(String*) { assert(fixed == 1); return &str_value; }
1787
1747
  my_decimal *val_decimal(my_decimal *);
1788
1748
  int save_in_field(Field *field, bool no_conversions);
1789
1749
  enum Item_result result_type () const { return STRING_RESULT; }
1790
1750
  enum Item_result cast_to_int_type() const { return INT_RESULT; }
1791
 
  enum_field_types field_type() const { return DRIZZLE_TYPE_VARCHAR; }
 
1751
  enum_field_types field_type() const { return MYSQL_TYPE_VARCHAR; }
1792
1752
  virtual void print(String *str, enum_query_type query_type);
1793
1753
  bool eq(const Item *item, bool binary_cmp) const;
1794
 
  virtual Item *safe_charset_converter(const CHARSET_INFO * const tocs);
1795
 
  bool check_vcol_func_processor(unsigned char *arg __attribute__((unused)))
1796
 
  { return false; }
 
1754
  virtual Item *safe_charset_converter(CHARSET_INFO *tocs);
1797
1755
};
1798
1756
 
1799
1757
 
1800
1758
class Item_bin_string: public Item_hex_string
1801
1759
{
1802
1760
public:
1803
 
  Item_bin_string(const char *str,uint32_t str_length);
 
1761
  Item_bin_string(const char *str,uint str_length);
1804
1762
};
1805
1763
 
1806
1764
class Item_result_field :public Item    /* Item with result field */
1814
1772
  {}
1815
1773
  ~Item_result_field() {}                       /* Required with gcc 2.95 */
1816
1774
  Field *get_tmp_table_field() { return result_field; }
1817
 
  Field *tmp_table_field(Table *t_arg __attribute__((unused)))
 
1775
  Field *tmp_table_field(TABLE *t_arg __attribute__((__unused__)))
1818
1776
  { return result_field; }
1819
1777
  table_map used_tables() const { return 1; }
1820
1778
  virtual void fix_length_and_dec()=0;
1825
1783
    save_in_field(result_field, no_conversions);
1826
1784
  }
1827
1785
  void cleanup();
1828
 
  bool check_vcol_func_processor(unsigned char *arg __attribute__((unused)))
1829
 
  { return false; }
1830
1786
};
1831
1787
 
1832
1788
 
1859
1815
  */
1860
1816
  Item_ref(Name_resolution_context *context_arg, Item **item,
1861
1817
           const char *table_name_arg, const char *field_name_arg,
1862
 
           bool alias_name_used_arg= false);
 
1818
           bool alias_name_used_arg= FALSE);
1863
1819
 
1864
1820
  /* Constructor need to process subselect with temporary tables (see Item) */
1865
1821
  Item_ref(THD *thd, Item_ref *item)
1871
1827
    return ref && (*ref)->eq(it, binary_cmp);
1872
1828
  }
1873
1829
  double val_real();
1874
 
  int64_t val_int();
 
1830
  longlong val_int();
1875
1831
  my_decimal *val_decimal(my_decimal *);
1876
1832
  bool val_bool();
1877
1833
  String *val_str(String* tmp);
1878
1834
  bool is_null();
1879
 
  bool get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate);
 
1835
  bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
1880
1836
  double val_result();
1881
 
  int64_t val_int_result();
 
1837
  longlong val_int_result();
1882
1838
  String *str_result(String* tmp);
1883
1839
  my_decimal *val_decimal_result(my_decimal *);
1884
1840
  bool val_bool_result();
1913
1869
  {
1914
1870
    return ref ? (*ref)->real_item() : this;
1915
1871
  }
1916
 
  bool walk(Item_processor processor, bool walk_subquery, unsigned char *arg)
 
1872
  bool walk(Item_processor processor, bool walk_subquery, uchar *arg)
1917
1873
  { return (*ref)->walk(processor, walk_subquery, arg); }
1918
1874
  virtual void print(String *str, enum_query_type query_type);
1919
 
  bool result_as_int64_t()
 
1875
  bool result_as_longlong()
1920
1876
  {
1921
 
    return (*ref)->result_as_int64_t();
 
1877
    return (*ref)->result_as_longlong();
1922
1878
  }
1923
1879
  void cleanup();
1924
1880
  Item_field *filed_for_view_update()
1926
1882
  virtual Ref_Type ref_type() { return REF; }
1927
1883
 
1928
1884
  // Row emulation: forwarding of ROW-related calls to ref
1929
 
  uint32_t cols()
 
1885
  uint cols()
1930
1886
  {
1931
1887
    return ref && result_type() == ROW_RESULT ? (*ref)->cols() : 1;
1932
1888
  }
1933
 
  Item* element_index(uint32_t i)
 
1889
  Item* element_index(uint i)
1934
1890
  {
1935
1891
    return ref && result_type() == ROW_RESULT ? (*ref)->element_index(i) : this;
1936
1892
  }
1937
 
  Item** addr(uint32_t i)
 
1893
  Item** addr(uint i)
1938
1894
  {
1939
1895
    return ref && result_type() == ROW_RESULT ? (*ref)->addr(i) : 0;
1940
1896
  }
1941
 
  bool check_cols(uint32_t c)
 
1897
  bool check_cols(uint c)
1942
1898
  {
1943
1899
    return ref && result_type() == ROW_RESULT ? (*ref)->check_cols(c) 
1944
1900
                                              : Item::check_cols(c);
1966
1922
  Item_direct_ref(Name_resolution_context *context_arg, Item **item,
1967
1923
                  const char *table_name_arg,
1968
1924
                  const char *field_name_arg,
1969
 
                  bool alias_name_used_arg= false)
 
1925
                  bool alias_name_used_arg= FALSE)
1970
1926
    :Item_ref(context_arg, item, table_name_arg,
1971
1927
              field_name_arg, alias_name_used_arg)
1972
1928
  {}
1974
1930
  Item_direct_ref(THD *thd, Item_direct_ref *item) : Item_ref(thd, item) {}
1975
1931
 
1976
1932
  double val_real();
1977
 
  int64_t val_int();
 
1933
  longlong val_int();
1978
1934
  String *val_str(String* tmp);
1979
1935
  my_decimal *val_decimal(my_decimal *);
1980
1936
  bool val_bool();
1981
1937
  bool is_null();
1982
 
  bool get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate);
 
1938
  bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
1983
1939
  virtual Ref_Type ref_type() { return DIRECT_REF; }
1984
1940
};
1985
1941
 
2028
1984
  /* The aggregate function under which this outer ref is used, if any. */
2029
1985
  Item_sum *in_sum_func;
2030
1986
  /*
2031
 
    true <=> that the outer_ref is already present in the select list
 
1987
    TRUE <=> that the outer_ref is already present in the select list
2032
1988
    of the outer select.
2033
1989
  */
2034
1990
  bool found_in_select_list;
2050
2006
                     alias_name_used_arg),
2051
2007
    outer_ref(0), in_sum_func(0), found_in_select_list(1)
2052
2008
  {}
2053
 
  void save_in_result_field(bool no_conversions __attribute__((unused)))
 
2009
  void save_in_result_field(bool no_conversions __attribute__((__unused__)))
2054
2010
  {
2055
2011
    outer_ref->save_org_in_field(result_field);
2056
2012
  }
2070
2026
/*
2071
2027
  An object of this class:
2072
2028
   - Converts val_XXX() calls to ref->val_XXX_result() calls, like Item_ref.
2073
 
   - Sets owner->was_null=true if it has returned a NULL value from any
 
2029
   - Sets owner->was_null=TRUE if it has returned a NULL value from any
2074
2030
     val_XXX() function. This allows to inject an Item_ref_null_helper
2075
2031
     object into subquery and then check if the subquery has produced a row
2076
2032
     with NULL value.
2087
2043
    :Item_ref(context_arg, item, table_name_arg, field_name_arg),
2088
2044
     owner(master) {}
2089
2045
  double val_real();
2090
 
  int64_t val_int();
 
2046
  longlong val_int();
2091
2047
  String* val_str(String* s);
2092
2048
  my_decimal *val_decimal(my_decimal *);
2093
2049
  bool val_bool();
2094
 
  bool get_date(DRIZZLE_TIME *ltime, uint32_t fuzzydate);
 
2050
  bool get_date(MYSQL_TIME *ltime, uint fuzzydate);
2095
2051
  virtual void print(String *str, enum_query_type query_type);
2096
2052
  /*
2097
2053
    we add RAND_TABLE_BIT to prevent moving this item from HAVING to WHERE
2117
2073
{
2118
2074
  Item *ref;
2119
2075
public:
2120
 
  Item_int_with_ref(int64_t i, Item *ref_arg, bool unsigned_arg) :
 
2076
  Item_int_with_ref(longlong i, Item *ref_arg, my_bool unsigned_arg) :
2121
2077
    Item_int(i), ref(ref_arg)
2122
2078
  {
2123
2079
    unsigned_flag= unsigned_arg;
2130
2086
  virtual Item *real_item() { return ref; }
2131
2087
};
2132
2088
 
2133
 
#ifdef DRIZZLE_SERVER
 
2089
#ifdef MYSQL_SERVER
2134
2090
#include "item_sum.h"
2135
2091
#include "item_func.h"
2136
2092
#include "item_row.h"
2147
2103
  Item *item;
2148
2104
  Item_copy_string(Item *i) :item(i)
2149
2105
  {
2150
 
    null_value= maybe_null= item->maybe_null;
 
2106
    null_value=maybe_null=item->maybe_null;
2151
2107
    decimals=item->decimals;
2152
2108
    max_length=item->max_length;
2153
2109
    name=item->name;
2161
2117
    int err_not_used;
2162
2118
    char *end_not_used;
2163
2119
    return (null_value ? 0.0 :
2164
 
            my_strntod(str_value.charset(), (char*) str_value.ptr(),
2165
 
                       str_value.length(), &end_not_used, &err_not_used));
 
2120
            my_strntod(str_value.charset(), (char*) str_value.ptr(),
 
2121
                       str_value.length(), &end_not_used, &err_not_used));
2166
2122
  }
2167
 
  int64_t val_int()
 
2123
  longlong val_int()
2168
2124
  {
2169
2125
    int err;
2170
 
    return null_value ? 0 : my_strntoll(str_value.charset(),str_value.ptr(),
2171
 
                                        str_value.length(),10, (char**) 0,
2172
 
                                        &err);
 
2126
    return null_value ? 0LL : my_strntoll(str_value.charset(),str_value.ptr(),
 
2127
                                            str_value.length(),10, (char**) 0,
 
2128
                                            &err); 
2173
2129
  }
2174
2130
  String *val_str(String*);
2175
2131
  my_decimal *val_decimal(my_decimal *);
2176
2132
  void make_field(Send_field *field) { item->make_field(field); }
2177
2133
  void copy();
2178
2134
  int save_in_field(Field *field,
2179
 
                    bool no_conversions __attribute__((unused)))
 
2135
                    bool no_conversions __attribute__((__unused__)))
2180
2136
  {
2181
2137
    return save_str_value_in_field(field, &str_value);
2182
2138
  }
2189
2145
class Cached_item :public Sql_alloc
2190
2146
{
2191
2147
public:
2192
 
  bool null_value;
 
2148
  my_bool null_value;
2193
2149
  Cached_item() :null_value(0) {}
2194
2150
  virtual bool cmp(void)=0;
2195
2151
  virtual ~Cached_item(); /*line -e1509 */
2218
2174
class Cached_item_int :public Cached_item
2219
2175
{
2220
2176
  Item *item;
2221
 
  int64_t value;
 
2177
  longlong value;
2222
2178
public:
2223
2179
  Cached_item_int(Item *item_par) :item(item_par),value(0) {}
2224
2180
  bool cmp(void);
2236
2192
 
2237
2193
class Cached_item_field :public Cached_item
2238
2194
{
2239
 
  unsigned char *buff;
 
2195
  uchar *buff;
2240
2196
  Field *field;
2241
 
  uint32_t length;
 
2197
  uint length;
2242
2198
 
2243
2199
public:
2244
2200
  Cached_item_field(Field *arg_field) : field(arg_field)
2245
2201
  {
2246
2202
    field= arg_field;
2247
2203
    /* TODO: take the memory allocation below out of the constructor. */
2248
 
    buff= (unsigned char*) sql_calloc(length=field->pack_length());
 
2204
    buff= (uchar*) sql_calloc(length=field->pack_length());
2249
2205
  }
2250
2206
  bool cmp(void);
2251
2207
};
2269
2225
  int save_in_field(Field *field_arg, bool no_conversions);
2270
2226
  table_map used_tables() const { return (table_map)0L; }
2271
2227
 
2272
 
  bool walk(Item_processor processor, bool walk_subquery, unsigned char *args)
 
2228
  bool walk(Item_processor processor, bool walk_subquery, uchar *args)
2273
2229
  {
2274
2230
    return arg->walk(processor, walk_subquery, args) ||
2275
2231
      (this->*processor)(args);
2276
2232
  }
2277
2233
 
2278
 
  Item *transform(Item_transformer transformer, unsigned char *args);
 
2234
  Item *transform(Item_transformer transformer, uchar *args);
2279
2235
};
2280
2236
 
2281
2237
/*
2309
2265
  */
2310
2266
  table_map used_tables() const { return RAND_TABLE_BIT; }
2311
2267
 
2312
 
  bool walk(Item_processor processor, bool walk_subquery, unsigned char *args)
 
2268
  bool walk(Item_processor processor, bool walk_subquery, uchar *args)
2313
2269
  {
2314
2270
    return arg->walk(processor, walk_subquery, args) ||
2315
2271
            (this->*processor)(args);
2316
2272
  }
2317
 
  bool check_vcol_func_processor(unsigned char *arg __attribute__((unused)))
2318
 
  { return true; }
2319
2273
};
2320
2274
 
2321
2275
 
2334
2288
  enum enum_field_types cached_field_type;
2335
2289
public:
2336
2290
  Item_cache(): 
2337
 
    example(0), used_table_map(0), cached_field(0), cached_field_type(DRIZZLE_TYPE_VARCHAR) 
 
2291
    example(0), used_table_map(0), cached_field(0), cached_field_type(MYSQL_TYPE_STRING) 
2338
2292
  {
2339
2293
    fixed= 1; 
2340
2294
    null_value= 1;
2348
2302
 
2349
2303
  void set_used_tables(table_map map) { used_table_map= map; }
2350
2304
 
2351
 
  virtual bool allocate(uint32_t i __attribute__((unused)))
 
2305
  virtual bool allocate(uint i __attribute__((__unused__)))
2352
2306
  { return 0; }
2353
2307
  virtual bool setup(Item *item)
2354
2308
  {
2370
2324
  virtual void print(String *str, enum_query_type query_type);
2371
2325
  bool eq_def(Field *field) 
2372
2326
  { 
2373
 
    return cached_field ? cached_field->eq_def (field) : false;
 
2327
    return cached_field ? cached_field->eq_def (field) : FALSE;
2374
2328
  }
2375
2329
  bool eq(const Item *item,
2376
 
          bool binary_cmp __attribute__((unused))) const
 
2330
          bool binary_cmp __attribute__((__unused__))) const
2377
2331
  {
2378
2332
    return this == item;
2379
2333
  }
2383
2337
class Item_cache_int: public Item_cache
2384
2338
{
2385
2339
protected:
2386
 
  int64_t value;
 
2340
  longlong value;
2387
2341
public:
2388
2342
  Item_cache_int(): Item_cache(), value(0) {}
2389
2343
  Item_cache_int(enum_field_types field_type_arg):
2390
2344
    Item_cache(field_type_arg), value(0) {}
2391
2345
 
2392
2346
  void store(Item *item);
2393
 
  void store(Item *item, int64_t val_arg);
 
2347
  void store(Item *item, longlong val_arg);
2394
2348
  double val_real() { assert(fixed == 1); return (double) value; }
2395
 
  int64_t val_int() { assert(fixed == 1); return value; }
 
2349
  longlong val_int() { assert(fixed == 1); return value; }
2396
2350
  String* val_str(String *str);
2397
2351
  my_decimal *val_decimal(my_decimal *);
2398
2352
  enum Item_result result_type() const { return INT_RESULT; }
2399
 
  bool result_as_int64_t() { return true; }
 
2353
  bool result_as_longlong() { return TRUE; }
2400
2354
};
2401
2355
 
2402
2356
 
2408
2362
 
2409
2363
  void store(Item *item);
2410
2364
  double val_real() { assert(fixed == 1); return value; }
2411
 
  int64_t val_int();
 
2365
  longlong val_int();
2412
2366
  String* val_str(String *str);
2413
2367
  my_decimal *val_decimal(my_decimal *);
2414
2368
  enum Item_result result_type() const { return REAL_RESULT; }
2424
2378
 
2425
2379
  void store(Item *item);
2426
2380
  double val_real();
2427
 
  int64_t val_int();
 
2381
  longlong val_int();
2428
2382
  String* val_str(String *str);
2429
2383
  my_decimal *val_decimal(my_decimal *);
2430
2384
  enum Item_result result_type() const { return DECIMAL_RESULT; }
2442
2396
    Item_cache(), value(0),
2443
2397
    is_varbinary(item->type() == FIELD_ITEM &&
2444
2398
                 ((const Item_field *) item)->field->type() ==
2445
 
                   DRIZZLE_TYPE_VARCHAR &&
 
2399
                   MYSQL_TYPE_VARCHAR &&
2446
2400
                 !((const Item_field *) item)->field->has_charset())
2447
2401
  {}
2448
2402
  void store(Item *item);
2449
2403
  double val_real();
2450
 
  int64_t val_int();
 
2404
  longlong val_int();
2451
2405
  String* val_str(String *) { assert(fixed == 1); return value; }
2452
2406
  my_decimal *val_decimal(my_decimal *);
2453
2407
  enum Item_result result_type() const { return STRING_RESULT; }
2454
 
  const CHARSET_INFO *charset() const { return value->charset(); };
 
2408
  CHARSET_INFO *charset() const { return value->charset(); };
2455
2409
  int save_in_field(Field *field, bool no_conversions);
2456
2410
};
2457
2411
 
2458
2412
class Item_cache_row: public Item_cache
2459
2413
{
2460
2414
  Item_cache  **values;
2461
 
  uint32_t item_count;
 
2415
  uint item_count;
2462
2416
  bool save_array;
2463
2417
public:
2464
2418
  Item_cache_row()
2468
2422
    'allocate' used only in row transformer, to preallocate space for row 
2469
2423
    cache.
2470
2424
  */
2471
 
  bool allocate(uint32_t num);
 
2425
  bool allocate(uint num);
2472
2426
  /*
2473
2427
    'setup' is needed only by row => it not called by simple row subselect
2474
2428
    (only by IN subselect (in subselect optimizer))
2485
2439
    illegal_method_call((const char*)"val");
2486
2440
    return 0;
2487
2441
  };
2488
 
  int64_t val_int()
 
2442
  longlong val_int()
2489
2443
  {
2490
2444
    illegal_method_call((const char*)"val_int");
2491
2445
    return 0;
2495
2449
    illegal_method_call((const char*)"val_str");
2496
2450
    return 0;
2497
2451
  };
2498
 
  my_decimal *val_decimal(my_decimal *val __attribute__((unused)))
 
2452
  my_decimal *val_decimal(my_decimal *val __attribute__((__unused__)))
2499
2453
  {
2500
2454
    illegal_method_call((const char*)"val_decimal");
2501
2455
    return 0;
2503
2457
 
2504
2458
  enum Item_result result_type() const { return ROW_RESULT; }
2505
2459
  
2506
 
  uint32_t cols() { return item_count; }
2507
 
  Item *element_index(uint32_t i) { return values[i]; }
2508
 
  Item **addr(uint32_t i) { return (Item **) (values + i); }
2509
 
  bool check_cols(uint32_t c);
 
2460
  uint cols() { return item_count; }
 
2461
  Item *element_index(uint i) { return values[i]; }
 
2462
  Item **addr(uint i) { return (Item **) (values + i); }
 
2463
  bool check_cols(uint c);
2510
2464
  bool null_inside();
2511
2465
  void bring_value();
2512
2466
  void keep_array() { save_array= 1; }
2514
2468
  {
2515
2469
    Item_cache::cleanup();
2516
2470
    if (save_array)
2517
 
      memset(values, 0, item_count*sizeof(Item**));
 
2471
      bzero(values, item_count*sizeof(Item**));
2518
2472
    else
2519
2473
      values= 0;
2520
2474
    return;
2546
2500
  enum_field_types field_type() const { return fld_type; };
2547
2501
  enum Type type() const { return TYPE_HOLDER; }
2548
2502
  double val_real();
2549
 
  int64_t val_int();
 
2503
  longlong val_int();
2550
2504
  my_decimal *val_decimal(my_decimal *);
2551
2505
  String *val_str(String*);
2552
2506
  bool join_types(THD *thd, Item *);
2553
 
  Field *make_field_by_type(Table *table);
2554
 
  static uint32_t display_length(Item *item);
 
2507
  Field *make_field_by_type(TABLE *table);
 
2508
  static uint32 display_length(Item *item);
2555
2509
  static enum_field_types get_real_type(Item *);
2556
2510
};
2557
2511
 
2567
2521
                                    bool use_result_field);
2568
2522
extern void resolve_const_item(THD *thd, Item **ref, Item *cmp_item);
2569
2523
extern bool field_is_equal_to_item(Field *field,Item *item);
2570
 
 
2571
 
#endif