1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
4
* Copyright (C) 2008 Sun Microsystems
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.
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.
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
20
#ifndef DRIZZLED_ITEM_H
21
#define DRIZZLED_ITEM_H
23
#include <drizzled/dtcollation.h>
24
#include <mysys/drizzle_time.h>
25
#include <drizzled/my_decimal.h>
26
#include <drizzled/sql_bitmap.h>
27
#include <drizzled/sql_list.h>
28
#include <drizzled/sql_alloc.h>
1
/* Copyright (C) 2000-2006 MySQL AB
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.
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.
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 */
17
#ifdef USE_PRAGMA_INTERFACE
18
#pragma interface /* gcc class implementation */
23
void item_init(void); /* Init item functions */
33
class Name_resolution_context;
38
class Item_in_subselect;
42
void item_init(void); /* Init item functions */
45
void dummy_error_processor(Session *session, void *data);
46
void view_error_processor(Session *session, void *data);
49
/*************************************************************************/
27
"Declared Type Collation"
28
A combination of collation and its derivation.
30
Flags for collation aggregation modes:
31
MY_COLL_ALLOW_SUPERSET_CONV - allow conversion to a superset
32
MY_COLL_ALLOW_COERCIBLE_CONV - allow conversion of a coercible value
34
MY_COLL_ALLOW_CONV - allow any kind of conversion
35
(combination of the above two)
36
MY_COLL_DISALLOW_NONE - don't allow return DERIVATION_NONE
37
(e.g. when aggregating for comparison)
38
MY_COLL_CMP_CONV - combination of MY_COLL_ALLOW_CONV
39
and MY_COLL_DISALLOW_NONE
42
#define MY_COLL_ALLOW_SUPERSET_CONV 1
43
#define MY_COLL_ALLOW_COERCIBLE_CONV 2
44
#define MY_COLL_ALLOW_CONV 3
45
#define MY_COLL_DISALLOW_NONE 4
46
#define MY_COLL_CMP_CONV 7
50
CHARSET_INFO *collation;
51
enum Derivation derivation;
54
void set_repertoire_from_charset(CHARSET_INFO *cs)
56
repertoire= cs->state & MY_CS_PUREASCII ?
57
MY_REPERTOIRE_ASCII : MY_REPERTOIRE_UNICODE30;
61
collation= &my_charset_bin;
62
derivation= DERIVATION_NONE;
63
repertoire= MY_REPERTOIRE_UNICODE30;
65
DTCollation(CHARSET_INFO *collation_arg, Derivation derivation_arg)
67
collation= collation_arg;
68
derivation= derivation_arg;
69
set_repertoire_from_charset(collation_arg);
71
void set(DTCollation &dt)
73
collation= dt.collation;
74
derivation= dt.derivation;
75
repertoire= dt.repertoire;
77
void set(CHARSET_INFO *collation_arg, Derivation derivation_arg)
79
collation= collation_arg;
80
derivation= derivation_arg;
81
set_repertoire_from_charset(collation_arg);
83
void set(CHARSET_INFO *collation_arg,
84
Derivation derivation_arg,
87
collation= collation_arg;
88
derivation= derivation_arg;
89
repertoire= repertoire_arg;
91
void set(CHARSET_INFO *collation_arg)
93
collation= collation_arg;
94
set_repertoire_from_charset(collation_arg);
96
void set(Derivation derivation_arg)
97
{ derivation= derivation_arg; }
98
bool aggregate(DTCollation &dt, uint flags= 0);
99
bool set(DTCollation &dt1, DTCollation &dt2, uint flags= 0)
100
{ set(dt1); return aggregate(dt2, flags); }
101
const char *derivation_name() const
105
case DERIVATION_IGNORABLE: return "IGNORABLE";
106
case DERIVATION_COERCIBLE: return "COERCIBLE";
107
case DERIVATION_IMPLICIT: return "IMPLICIT";
108
case DERIVATION_SYSCONST: return "SYSCONST";
109
case DERIVATION_EXPLICIT: return "EXPLICIT";
110
case DERIVATION_NONE: return "NONE";
111
default: return "UNKNOWN";
116
/*************************************************************************/
118
A framework to easily handle different return types for hybrid items
119
(hybrid item is an item whose operand can be of any type, e.g. integer,
123
struct Hybrid_type_traits;
131
Use two decimal buffers interchangeably to speed up += operation
132
which has no native support in decimal library.
133
Hybrid_type+= arg is implemented as dec_buf[1]= dec_buf[0] + arg.
134
The third decimal is used as a handy temporary storage.
136
my_decimal dec_buf[3];
140
Traits moved to a separate class to
141
a) be able to easily change object traits in runtime
142
b) they work as a differentiator for the union above
144
const Hybrid_type_traits *traits;
147
/* XXX: add traits->copy() when needed */
148
Hybrid_type(const Hybrid_type &rhs) :traits(rhs.traits) {}
152
/* Hybryd_type_traits interface + default implementation for REAL_RESULT */
154
struct Hybrid_type_traits
156
virtual Item_result type() const { return REAL_RESULT; }
159
fix_length_and_dec(Item *item, Item *arg) const;
161
/* Hybrid_type operations. */
162
virtual void set_zero(Hybrid_type *val) const { val->real= 0.0; }
163
virtual void add(Hybrid_type *val, Field *f) const
164
{ val->real+= f->val_real(); }
165
virtual void div(Hybrid_type *val, uint64_t u) const
166
{ val->real/= uint64_t2double(u); }
168
virtual int64_t val_int(Hybrid_type *val,
169
bool unsigned_flag __attribute__((__unused__))) const
170
{ return (int64_t) rint(val->real); }
171
virtual double val_real(Hybrid_type *val) const { return val->real; }
172
virtual my_decimal *val_decimal(Hybrid_type *val, my_decimal *buf) const;
173
virtual String *val_str(Hybrid_type *val, String *buf, uint8 decimals) const;
174
static const Hybrid_type_traits *instance();
175
Hybrid_type_traits() {}
176
virtual ~Hybrid_type_traits() {}
180
struct Hybrid_type_traits_decimal: public Hybrid_type_traits
182
virtual Item_result type() const { return DECIMAL_RESULT; }
185
fix_length_and_dec(Item *arg, Item *item) const;
187
/* Hybrid_type operations. */
188
virtual void set_zero(Hybrid_type *val) const;
189
virtual void add(Hybrid_type *val, Field *f) const;
190
virtual void div(Hybrid_type *val, uint64_t u) const;
192
virtual int64_t val_int(Hybrid_type *val, bool unsigned_flag) const;
193
virtual double val_real(Hybrid_type *val) const;
194
virtual my_decimal *val_decimal(Hybrid_type *val,
195
my_decimal *buf __attribute__((__unused__))) const
196
{ return &val->dec_buf[val->used_dec_buf_no]; }
197
virtual String *val_str(Hybrid_type *val, String *buf, uint8 decimals) const;
198
static const Hybrid_type_traits_decimal *instance();
199
Hybrid_type_traits_decimal() {};
203
struct Hybrid_type_traits_integer: public Hybrid_type_traits
205
virtual Item_result type() const { return INT_RESULT; }
208
fix_length_and_dec(Item *arg, Item *item) const;
210
/* Hybrid_type operations. */
211
virtual void set_zero(Hybrid_type *val) const
213
virtual void add(Hybrid_type *val, Field *f) const
214
{ val->integer+= f->val_int(); }
215
virtual void div(Hybrid_type *val, uint64_t u) const
216
{ val->integer/= (int64_t) u; }
218
virtual int64_t val_int(Hybrid_type *val,
219
bool unsigned_flag __attribute__((__unused__))) const
220
{ return val->integer; }
221
virtual double val_real(Hybrid_type *val) const
222
{ return (double) val->integer; }
223
virtual my_decimal *val_decimal(Hybrid_type *val,
224
my_decimal *buf __attribute__((__unused__))) const
226
int2my_decimal(E_DEC_FATAL_ERROR, val->integer, 0, &val->dec_buf[2]);
227
return &val->dec_buf[2];
229
virtual String *val_str(Hybrid_type *val, String *buf,
230
uint8 decimals __attribute__((__unused__))) const
231
{ buf->set(val->integer, &my_charset_bin); return buf;}
232
static const Hybrid_type_traits_integer *instance();
233
Hybrid_type_traits_integer() {};
237
void dummy_error_processor(THD *thd, void *data);
239
void view_error_processor(THD *thd, void *data);
242
Instances of Name_resolution_context store the information necesary for
243
name resolution of Items and other context analysis of a query made in
246
This structure is a part of SELECT_LEX, a pointer to this structure is
247
assigned when an item is created (which happens mostly during parsing
248
(sql_yacc.yy)), but the structure itself will be initialized after parsing
251
TODO: move subquery of INSERT ... SELECT and CREATE ... SELECT to
252
separate SELECT_LEX which allow to remove tricks of changing this
253
structure before and after INSERT/CREATE and its SELECT to make correct
254
field name resolution.
256
struct Name_resolution_context: Sql_alloc
259
The name resolution context to search in when an Item cannot be
260
resolved in this context (the context of an outer select)
262
Name_resolution_context *outer_context;
265
List of tables used to resolve the items of this context. Usually these
266
are tables from the FROM clause of SELECT statement. The exceptions are
267
INSERT ... SELECT and CREATE ... SELECT statements, where SELECT
268
subquery is not moved to a separate SELECT_LEX. For these types of
269
statements we have to change this member dynamically to ensure correct
270
name resolution of different parts of the statement.
272
TABLE_LIST *table_list;
274
In most cases the two table references below replace 'table_list' above
275
for the purpose of name resolution. The first and last name resolution
276
table references allow us to search only in a sub-tree of the nested
277
join tree in a FROM clause. This is needed for NATURAL JOIN, JOIN ... USING
280
TABLE_LIST *first_name_resolution_table;
282
Last table to search in the list of leaf table references that begins
283
with first_name_resolution_table.
285
TABLE_LIST *last_name_resolution_table;
288
SELECT_LEX item belong to, in case of merged VIEW it can differ from
289
SELECT_LEX where item was created, so we can't use table_list/field_list
292
st_select_lex *select_lex;
295
Processor of errors caused during Item name resolving, now used only to
296
hide underlying tables in errors about views (i.e. it substitute some
299
void (*error_processor)(THD *, void *);
300
void *error_processor_data;
303
When true items are resolved in this context both against the
304
SELECT list and this->table_list. If false, items are resolved
305
only against this->table_list.
307
bool resolve_in_select_list;
310
Security context of this name resolution context. It's used for views
311
and is non-zero only if the view is defined with SQL SECURITY DEFINER.
313
Security_context *security_ctx;
315
Name_resolution_context()
316
:outer_context(0), table_list(0), select_lex(0),
317
error_processor_data(0),
323
resolve_in_select_list= false;
324
error_processor= &dummy_error_processor;
325
first_name_resolution_table= NULL;
326
last_name_resolution_table= NULL;
329
void resolve_in_table_list_only(TABLE_LIST *tables)
331
table_list= first_name_resolution_table= tables;
332
resolve_in_select_list= false;
335
void process_error(THD *thd)
337
(*error_processor)(thd, error_processor_data);
343
Store and restore the current state of a name resolution context.
346
class Name_resolution_context_state
349
TABLE_LIST *save_table_list;
350
TABLE_LIST *save_first_name_resolution_table;
351
TABLE_LIST *save_next_name_resolution_table;
352
bool save_resolve_in_select_list;
353
TABLE_LIST *save_next_local;
356
Name_resolution_context_state() {} /* Remove gcc warning */
359
/* Save the state of a name resolution context. */
360
void save_state(Name_resolution_context *context, TABLE_LIST *table_list)
362
save_table_list= context->table_list;
363
save_first_name_resolution_table= context->first_name_resolution_table;
364
save_resolve_in_select_list= context->resolve_in_select_list;
365
save_next_local= table_list->next_local;
366
save_next_name_resolution_table= table_list->next_name_resolution_table;
369
/* Restore a name resolution context from saved state. */
370
void restore_state(Name_resolution_context *context, TABLE_LIST *table_list)
372
table_list->next_local= save_next_local;
373
table_list->next_name_resolution_table= save_next_name_resolution_table;
374
context->table_list= save_table_list;
375
context->first_name_resolution_table= save_first_name_resolution_table;
376
context->resolve_in_select_list= save_resolve_in_select_list;
379
TABLE_LIST *get_first_name_resolution_table()
381
return save_first_name_resolution_table;
387
This enum is used to report information about monotonicity of function
388
represented by Item* tree.
389
Monotonicity is defined only for Item* trees that represent table
390
partitioning expressions (i.e. have no subselects/user vars/PS parameters
391
etc etc). An Item* tree is assumed to have the same monotonicity properties
392
as its correspoinding function F:
394
[signed] int64_t F(field1, field2, ...) {
395
put values of field_i into table record buffer;
396
return item->val_int();
400
At the moment function monotonicity is not well defined (and so may be
401
incorrect) for Item trees with parameters/return types that are different
402
from INT_RESULT, may be NULL, or are unsigned.
403
It will be possible to address this issue once the related partitioning bugs
404
(BUG#16002, BUG#15447, BUG#13436) are fixed.
407
typedef enum monotonicity_info
409
NON_MONOTONIC, /* none of the below holds */
410
MONOTONIC_INCREASING, /* F() is unary and (x < y) => (F(x) <= F(y)) */
411
MONOTONIC_STRICT_INCREASING /* F() is unary and (x < y) => (F(x) < F(y)) */
412
} enum_monotonicity_info;
414
/*************************************************************************/
415
typedef bool (Item::*Item_processor) (uchar *arg);
53
419
argp in/out IN: Analysis parameter
54
420
OUT: Parameter to be passed to the transformer
57
423
true Invoke the transformer
61
typedef bool (Item::*Item_analyzer) (unsigned char **argp);
62
typedef Item* (Item::*Item_transformer) (unsigned char *arg);
427
typedef bool (Item::*Item_analyzer) (uchar **argp);
428
typedef Item* (Item::*Item_transformer) (uchar *arg);
63
429
typedef void (*Cond_traverser) (const Item *item, void *arg);
64
typedef bool (Item::*Item_processor) (unsigned char *arg);
67
class Item: public Sql_alloc
69
/* Prevent use of these */
434
Item(const Item &); /* Prevent use of these */
71
435
void operator=(Item &);
73
436
/* Cache of the result of is_expensive(). */
74
int8_t is_expensive_cache;
75
virtual bool is_expensive_processor(unsigned char *arg);
437
int8 is_expensive_cache;
438
virtual bool is_expensive_processor(uchar *arg __attribute__((__unused__)))
442
static void *operator new(size_t size)
443
{ return sql_alloc(size); }
444
static void *operator new(size_t size, MEM_ROOT *mem_root)
445
{ return alloc_root(mem_root, size); }
446
static void operator delete(void *ptr __attribute__((__unused__)),
447
size_t size __attribute__((__unused__)))
448
{ TRASH(ptr, size); }
449
static void operator delete(void *ptr __attribute__((__unused__)),
450
MEM_ROOT *mem_root __attribute__((__unused__)))
79
enum Type {FIELD_ITEM= 0,
453
enum Type {FIELD_ITEM= 0, FUNC_ITEM, SUM_FUNC_ITEM, STRING_ITEM,
454
INT_ITEM, REAL_ITEM, NULL_ITEM, VARBIN_ITEM,
455
COPY_STR_ITEM, FIELD_AVG_ITEM, DEFAULT_VALUE_ITEM,
456
PROC_ITEM,COND_ITEM, REF_ITEM, FIELD_STD_ITEM,
457
FIELD_VARIANCE_ITEM, INSERT_VALUE_ITEM,
458
SUBSELECT_ITEM, ROW_ITEM, CACHE_ITEM, TYPE_HOLDER,
459
PARAM_ITEM, TRIGGER_FIELD_ITEM, DECIMAL_ITEM,
460
XPATH_NODESET, XPATH_NODESET_CMP,
103
463
enum cond_result { COND_UNDEF,COND_OK,COND_TRUE,COND_FALSE };
105
465
enum traverse_order { POSTFIX, PREFIX };
467
/* Reuse size, only used by SP local variable assignment, otherwize 0 */
108
471
str_values's main purpose is to be used to cache the value in
111
474
String str_value;
113
/* Name from select */
475
char * name; /* Name from select */
116
476
/* Original item name (if it was renamed)*/
117
477
char * orig_name;
122
uint32_t name_length;
126
bool maybe_null; /* If item may be null */
127
bool null_value; /* if item is null */
130
bool fixed; /* If item fixed with fix_fields */
131
bool is_autogenerated_name; /* indicate was name of this Item
480
uint name_length; /* Length of name */
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
132
489
autogenerated or set by user */
133
490
DTCollation collation;
134
bool with_subselect; /* If this item is a subselect or some
491
my_bool with_subselect; /* If this item is a subselect or some
135
492
of its arguments is or contains a
136
493
subselect. Computed by fix_fields. */
137
494
Item_result cmp_context; /* Comparison context */
579
956
where 'cost' is either 'double' or some structure of various cost
582
virtual bool is_expensive();
959
virtual bool is_expensive()
961
if (is_expensive_cache < 0)
962
is_expensive_cache= walk(&Item::is_expensive_processor, 0, (uchar*)0);
963
return test(is_expensive_cache);
584
965
String *check_well_formed_result(String *str, bool send_error= 0);
585
bool eq_by_collation(Item *item, bool binary_cmp,
586
const CHARSET_INFO * const cs);
590
#include <drizzled/item/basic_constant.h>
591
#include <drizzled/item/bin_string.h>
592
#include <drizzled/item/blob.h>
593
#include <drizzled/item/cache.h>
594
#include <drizzled/item/copy_string.h>
595
#include <drizzled/item/ident.h>
596
#include <drizzled/item/decimal.h>
597
#include <drizzled/item/direct_ref.h>
598
#include <drizzled/item/empty_string.h>
599
#include <drizzled/item/field.h>
600
#include <drizzled/item/hex_string.h>
601
#include <drizzled/item/ifloat.h>
602
#include <drizzled/item/istring.h>
603
#include <drizzled/item/int.h>
604
#include <drizzled/item/int_with_ref.h>
605
#include <drizzled/item/null.h>
606
#include <drizzled/item/num.h>
607
#include <drizzled/item/outer_ref.h>
608
#include <drizzled/item/param.h>
609
#include <drizzled/item/ref.h>
610
#include <drizzled/item/ref_null_helper.h>
611
#include <drizzled/item/return_date_time.h>
612
#include <drizzled/item/return_int.h>
613
#include <drizzled/item/uint.h>
615
void mark_as_dependent(Session *session,
617
st_select_lex *current,
618
Item_ident *resolved_item,
619
Item_ident *mark_item);
621
Item** resolve_ref_in_select_and_group(Session *session,
623
st_select_lex *select);
626
void mark_select_range_as_dependent(Session *session,
966
bool eq_by_collation(Item *item, bool binary_cmp, CHARSET_INFO *cs);
970
class Item_basic_constant :public Item
973
/* to prevent drop fixed flag (no need parent cleanup call) */
977
Restore the original field name as it might not have been allocated
978
in the statement memory. If the name is auto generated, it must be
979
done again between subsequent executions of a prepared statement.
986
bool agg_item_collations(DTCollation &c, const char *name,
987
Item **items, uint nitems, uint flags, int item_sep);
988
bool agg_item_collations_for_comparison(DTCollation &c, const char *name,
989
Item **items, uint nitems, uint flags);
990
bool agg_item_charsets(DTCollation &c, const char *name,
991
Item **items, uint nitems, uint flags, int item_sep);
994
class Item_num: public Item_basic_constant
997
Item_num() {} /* Remove gcc warning */
998
virtual Item_num *neg()= 0;
999
Item *safe_charset_converter(CHARSET_INFO *tocs);
1002
#define NO_CACHED_FIELD_INDEX ((uint)(-1))
1004
class st_select_lex;
1005
class Item_ident :public Item
1009
We have to store initial values of db_name, table_name and field_name
1010
to be able to restore them during cleanup() because they can be
1011
updated during fix_fields() to values from Field object and life-time
1012
of those is shorter than life-time of Item_field.
1014
const char *orig_db_name;
1015
const char *orig_table_name;
1016
const char *orig_field_name;
1019
Name_resolution_context *context;
1020
const char *db_name;
1021
const char *table_name;
1022
const char *field_name;
1023
bool alias_name_used; /* true if item was resolved against alias */
1025
Cached value of index for this field in table->field array, used by prep.
1026
stmts for speeding up their re-execution. Holds NO_CACHED_FIELD_INDEX
1027
if index value is not known.
1029
uint cached_field_index;
1031
Cached pointer to table which contains this field, used for the same reason
1032
by prep. stmt. too in case then we have not-fully qualified field.
1033
0 - means no cached value.
1035
TABLE_LIST *cached_table;
1036
st_select_lex *depended_from;
1037
Item_ident(Name_resolution_context *context_arg,
1038
const char *db_name_arg, const char *table_name_arg,
1039
const char *field_name_arg);
1040
Item_ident(THD *thd, Item_ident *item);
1041
const char *full_name() const;
1043
bool remove_dependence_processor(uchar * arg);
1044
virtual void print(String *str, enum_query_type query_type);
1045
virtual bool change_context_processor(uchar *cntx)
1046
{ context= (Name_resolution_context *)cntx; return false; }
1047
friend bool insert_fields(THD *thd, Name_resolution_context *context,
1048
const char *db_name,
1049
const char *table_name, List_iterator<Item> *it,
1050
bool any_privileges);
1054
class Item_ident_for_show :public Item
1058
const char *db_name;
1059
const char *table_name;
1061
Item_ident_for_show(Field *par_field, const char *db_arg,
1062
const char *table_name_arg)
1063
:field(par_field), db_name(db_arg), table_name(table_name_arg)
1066
enum Type type() const { return FIELD_ITEM; }
1067
double val_real() { return field->val_real(); }
1068
int64_t val_int() { return field->val_int(); }
1069
String *val_str(String *str) { return field->val_str(str); }
1070
my_decimal *val_decimal(my_decimal *dec) { return field->val_decimal(dec); }
1071
void make_field(Send_field *tmp_field);
1078
class Item_field :public Item_ident
1081
void set_field(Field *field);
1083
Field *field,*result_field;
1084
Item_equal *item_equal;
1085
bool no_const_subst;
1087
if any_privileges set to true then here real effective privileges will
1090
uint have_privileges;
1091
/* field need any privileges (for VIEW creation) */
1092
bool any_privileges;
1093
Item_field(Name_resolution_context *context_arg,
1094
const char *db_arg,const char *table_name_arg,
1095
const char *field_name_arg);
1097
Constructor needed to process subselect with temporary tables (see Item)
1099
Item_field(THD *thd, Item_field *item);
1101
Constructor used inside setup_wild(), ensures that field, table,
1102
and database names will live as long as Item_field (this is important
1103
in prepared statements).
1105
Item_field(THD *thd, Name_resolution_context *context_arg, Field *field);
1107
If this constructor is used, fix_fields() won't work, because
1108
db_name, table_name and column_name are unknown. It's necessary to call
1109
reset_field() before fix_fields() for all fields created this way.
1111
Item_field(Field *field);
1112
enum Type type() const { return FIELD_ITEM; }
1113
bool eq(const Item *item, bool binary_cmp) const;
1116
my_decimal *val_decimal(my_decimal *);
1117
String *val_str(String*);
1118
double val_result();
1119
int64_t val_int_result();
1120
String *str_result(String* tmp);
1121
my_decimal *val_decimal_result(my_decimal *);
1122
bool val_bool_result();
1123
bool send(Protocol *protocol, String *str_arg);
1124
void reset_field(Field *f);
1125
bool fix_fields(THD *, Item **);
1126
void fix_after_pullout(st_select_lex *new_parent, Item **ref);
1127
void make_field(Send_field *tmp_field);
1128
int save_in_field(Field *field,bool no_conversions);
1129
void save_org_in_field(Field *field);
1130
table_map used_tables() const;
1131
enum Item_result result_type () const
1133
return field->result_type();
1135
Item_result cast_to_int_type() const
1137
return field->cast_to_int_type();
1139
enum_field_types field_type() const
1141
return field->type();
1143
enum_monotonicity_info get_monotonicity_info() const
1145
return MONOTONIC_STRICT_INCREASING;
1147
int64_t val_int_endpoint(bool left_endp, bool *incl_endp);
1148
Field *get_tmp_table_field() { return result_field; }
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);
1153
bool is_null() { return field->is_null(); }
1154
void update_null_value();
1155
Item *get_tmp_table_item(THD *thd);
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);
1160
bool result_as_int64_t()
1162
return field->can_be_compared_as_int64_t();
1164
Item_equal *find_item_equal(COND_EQUAL *cond_equal);
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(); }
1170
Item_field *filed_for_view_update() { return this; }
1171
Item *safe_charset_converter(CHARSET_INFO *tocs);
1172
int fix_outer_field(THD *thd, Field **field, Item **reference);
1173
virtual Item *update_value_transformer(uchar *select_arg);
1174
virtual void print(String *str, enum_query_type query_type);
1176
friend class Item_default_value;
1177
friend class Item_insert_value;
1178
friend class st_select_lex_unit;
1181
class Item_null :public Item_basic_constant
1184
Item_null(char *name_par=0)
1186
maybe_null= null_value= true;
1188
name= name_par ? name_par : (char*) "NULL";
1190
collation.set(&my_charset_bin, DERIVATION_IGNORABLE);
1192
enum Type type() const { return NULL_ITEM; }
1193
bool eq(const Item *item, bool binary_cmp) const;
1196
String *val_str(String *str);
1197
my_decimal *val_decimal(my_decimal *);
1198
int save_in_field(Field *field, bool no_conversions);
1199
int save_safe_in_field(Field *field);
1200
bool send(Protocol *protocol, String *str);
1201
enum Item_result result_type () const { return STRING_RESULT; }
1202
enum_field_types field_type() const { return MYSQL_TYPE_NULL; }
1203
bool basic_const_item() const { return 1; }
1204
Item *clone_item() { return new Item_null(name); }
1205
bool is_null() { return 1; }
1207
virtual inline void print(String *str,
1208
enum_query_type query_type __attribute__((__unused__)))
1210
str->append(STRING_WITH_LEN("NULL"));
1213
Item *safe_charset_converter(CHARSET_INFO *tocs);
1216
class Item_null_result :public Item_null
1219
Field *result_field;
1220
Item_null_result() : Item_null(), result_field(0) {}
1221
bool is_result_field() { return result_field != 0; }
1222
void save_in_result_field(bool no_conversions)
1224
save_in_field(result_field, no_conversions);
1228
/* Item represents one placeholder ('?') of prepared statement */
1230
class Item_param :public Item
1232
char cnvbuf[MAX_FIELD_WIDTH];
1237
enum enum_item_param_state
1239
NO_VALUE, NULL_VALUE, INT_VALUE, REAL_VALUE,
1240
STRING_VALUE, TIME_VALUE, LONG_DATA_VALUE,
1245
A buffer for string and long data values. Historically all allocated
1246
values returned from val_str() were treated as eligible to
1247
modification. I. e. in some cases Item_func_concat can append it's
1248
second argument to return value of the first one. Because of that we
1249
can't return the original buffer holding string data from val_str(),
1250
and have to have one buffer for data and another just pointing to
1251
the data. This is the latter one and it's returned from val_str().
1252
Can not be declared inside the union as it's not a POD type.
1254
String str_value_ptr;
1255
my_decimal decimal_value;
1261
Character sets conversion info for string values.
1262
Character sets of client and connection defined at bind time are used
1263
for all conversions, even if one of them is later changed (i.e.
1264
between subsequent calls to mysql_stmt_execute).
1266
struct CONVERSION_INFO
1268
CHARSET_INFO *character_set_client;
1269
CHARSET_INFO *character_set_of_placeholder;
1271
This points at character set of connection if conversion
1272
to it is required (i. e. if placeholder typecode is not BLOB).
1273
Otherwise it's equal to character_set_client (to simplify
1274
check in convert_str_value()).
1276
CHARSET_INFO *final_character_set_of_str_value;
1281
/* Cached values for virtual methods to save us one switch. */
1282
enum Item_result item_result_type;
1283
enum Type item_type;
1286
Used when this item is used in a temporary table.
1287
This is NOT placeholder metadata sent to client, as this value
1288
is assigned after sending metadata (in setup_one_conversion_function).
1289
For example in case of 'SELECT ?' you'll get MYSQL_TYPE_STRING both
1290
in result set and placeholders metadata, no matter what type you will
1291
supply for this placeholder in mysql_stmt_execute.
1293
enum enum_field_types param_type;
1295
Offset of placeholder inside statement text. Used to create
1296
no-placeholders version of this statement for the binary log.
1300
Item_param(uint pos_in_query_arg);
1302
enum Item_result result_type () const { return item_result_type; }
1303
enum Type type() const { return item_type; }
1304
enum_field_types field_type() const { return param_type; }
1308
my_decimal *val_decimal(my_decimal*);
1309
String *val_str(String*);
1310
bool get_time(MYSQL_TIME *tm);
1311
bool get_date(MYSQL_TIME *tm, uint fuzzydate);
1312
int save_in_field(Field *field, bool no_conversions);
1315
void set_int(int64_t i, uint32 max_length_arg);
1316
void set_double(double i);
1317
void set_decimal(const char *str, ulong length);
1318
bool set_str(const char *str, ulong length);
1319
bool set_longdata(const char *str, ulong length);
1320
void set_time(MYSQL_TIME *tm, timestamp_type type, uint32 max_length_arg);
1321
bool set_from_user_var(THD *thd, const user_var_entry *entry);
1324
Assign placeholder value from bind data.
1325
Note, that 'len' has different semantics in embedded library (as we
1326
don't need to check that packet is not broken there). See
1327
sql_prepare.cc for details.
1329
void (*set_param_func)(Item_param *param, uchar **pos, ulong len);
1331
const String *query_val_str(String *str) const;
1333
bool convert_str_value(THD *thd);
1336
If value for parameter was not set we treat it as non-const
1337
so noone will use parameters value in fix_fields still
1338
parameter is constant during execution.
1340
virtual table_map used_tables() const
1341
{ return state != NO_VALUE ? (table_map)0 : PARAM_TABLE_BIT; }
1342
virtual void print(String *str, enum_query_type query_type);
1344
{ assert(state != NO_VALUE); return state == NULL_VALUE; }
1345
bool basic_const_item() const;
1347
This method is used to make a copy of a basic constant item when
1348
propagating constants in the optimizer. The reason to create a new
1349
item and not use the existing one is not precisely known (2005/04/16).
1350
Probably we are trying to preserve tree structure of items, in other
1351
words, avoid pointing at one item from two different nodes of the tree.
1352
Return a new basic constant item if parameter value is a basic
1353
constant, assert otherwise. This method is called only if
1354
basic_const_item returned true.
1356
Item *safe_charset_converter(CHARSET_INFO *tocs);
1359
Implement by-value equality evaluation if parameter value
1360
is set and is a basic constant (integer, real or string).
1361
Otherwise return false.
1363
bool eq(const Item *item, bool binary_cmp) const;
1364
/** Item is a argument to a limit clause. */
1365
bool limit_clause_param;
1369
class Item_int :public Item_num
1373
Item_int(int32 i,uint length= MY_INT32_NUM_DECIMAL_DIGITS)
1375
{ max_length=length; fixed= 1; }
1376
Item_int(int64_t i,uint length= MY_INT64_NUM_DECIMAL_DIGITS)
1378
{ max_length=length; fixed= 1; }
1379
Item_int(uint64_t i, uint length= MY_INT64_NUM_DECIMAL_DIGITS)
1381
{ max_length=length; fixed= 1; unsigned_flag= 1; }
1382
Item_int(const char *str_arg,int64_t i,uint length) :value(i)
1383
{ max_length=length; name=(char*) str_arg; fixed= 1; }
1384
Item_int(const char *str_arg, uint length=64);
1385
enum Type type() const { return INT_ITEM; }
1386
enum Item_result result_type () const { return INT_RESULT; }
1387
enum_field_types field_type() const { return MYSQL_TYPE_LONGLONG; }
1388
int64_t val_int() { assert(fixed == 1); return value; }
1389
double val_real() { assert(fixed == 1); return (double) value; }
1390
my_decimal *val_decimal(my_decimal *);
1391
String *val_str(String*);
1392
int save_in_field(Field *field, bool no_conversions);
1393
bool basic_const_item() const { return 1; }
1394
Item *clone_item() { return new Item_int(name,value,max_length); }
1395
virtual void print(String *str, enum_query_type query_type);
1396
Item_num *neg() { value= -value; return this; }
1397
uint decimal_precision() const
1398
{ return (uint)(max_length - test(value < 0)); }
1399
bool eq(const Item *, bool binary_cmp) const;
1403
class Item_uint :public Item_int
1406
Item_uint(const char *str_arg, uint length);
1407
Item_uint(uint64_t i) :Item_int((uint64_t) i, 10) {}
1408
Item_uint(const char *str_arg, int64_t i, uint length);
1410
{ assert(fixed == 1); return uint64_t2double((uint64_t)value); }
1411
String *val_str(String*);
1412
Item *clone_item() { return new Item_uint(name, value, max_length); }
1413
int save_in_field(Field *field, bool no_conversions);
1414
virtual void print(String *str, enum_query_type query_type);
1416
uint decimal_precision() const { return max_length; }
1420
/* decimal (fixed point) constant */
1421
class Item_decimal :public Item_num
1424
my_decimal decimal_value;
1426
Item_decimal(const char *str_arg, uint length, CHARSET_INFO *charset);
1427
Item_decimal(const char *str, const my_decimal *val_arg,
1428
uint decimal_par, uint length);
1429
Item_decimal(my_decimal *value_par);
1430
Item_decimal(int64_t val, bool unsig);
1431
Item_decimal(double val, int precision, int scale);
1432
Item_decimal(const uchar *bin, int precision, int scale);
1434
enum Type type() const { return DECIMAL_ITEM; }
1435
enum Item_result result_type () const { return DECIMAL_RESULT; }
1436
enum_field_types field_type() const { return MYSQL_TYPE_NEWDECIMAL; }
1439
String *val_str(String*);
1440
my_decimal *val_decimal(my_decimal *val __attribute__((__unused__)))
1441
{ return &decimal_value; }
1442
int save_in_field(Field *field, bool no_conversions);
1443
bool basic_const_item() const { return 1; }
1446
return new Item_decimal(name, &decimal_value, decimals, max_length);
1448
virtual void print(String *str, enum_query_type query_type);
1451
my_decimal_neg(&decimal_value);
1452
unsigned_flag= !decimal_value.sign();
1455
uint decimal_precision() const { return decimal_value.precision(); }
1456
bool eq(const Item *, bool binary_cmp) const;
1457
void set_decimal_value(my_decimal *value_par);
1461
class Item_float :public Item_num
1466
// Item_real() :value(0) {}
1467
Item_float(const char *str_arg, uint length);
1468
Item_float(const char *str,double val_arg,uint decimal_par,uint length)
1471
presentation= name=(char*) str;
1472
decimals=(uint8) decimal_par;
1476
Item_float(double value_par, uint decimal_par) :presentation(0), value(value_par)
1478
decimals= (uint8) decimal_par;
1481
int save_in_field(Field *field, bool no_conversions);
1482
enum Type type() const { return REAL_ITEM; }
1483
enum_field_types field_type() const { return MYSQL_TYPE_DOUBLE; }
1484
double val_real() { assert(fixed == 1); return value; }
1488
if (value <= (double) INT64_MIN)
1492
else if (value >= (double) (uint64_t) INT64_MAX)
1496
return (int64_t) rint(value);
1498
String *val_str(String*);
1499
my_decimal *val_decimal(my_decimal *);
1500
bool basic_const_item() const { return 1; }
1502
{ return new Item_float(name, value, decimals, max_length); }
1503
Item_num *neg() { value= -value; return this; }
1504
virtual void print(String *str, enum_query_type query_type);
1505
bool eq(const Item *, bool binary_cmp) const;
1509
class Item_static_float_func :public Item_float
1511
const char *func_name;
1513
Item_static_float_func(const char *str, double val_arg, uint decimal_par,
1515
:Item_float(NullS, val_arg, decimal_par, length), func_name(str)
1518
virtual inline void print(String *str,
1519
enum_query_type query_type __attribute__((__unused__)))
1521
str->append(func_name);
1524
Item *safe_charset_converter(CHARSET_INFO *tocs);
1528
class Item_string :public Item_basic_constant
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)
1536
str_value.set_or_copy_aligned(str, length, cs);
1537
collation.set(cs, dv, repertoire);
1539
We have to have a different max_length than 'length' here to
1540
ensure that we get the right length if we do use the item
1541
to create a new table. In this case max_length must be the maximum
1542
number of chars for a string of this type because we in Create_field::
1543
divide the max_length with mbmaxlen).
1545
max_length= str_value.numchars()*cs->mbmaxlen;
1546
set_name(str, length, cs);
1547
decimals=NOT_FIXED_DEC;
1548
// it is constant => can be used without fix_fields (and frequently used)
1551
/* Just create an item and do not fill string representation */
1552
Item_string(CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE)
1553
: m_cs_specified(false)
1555
collation.set(cs, dv);
1557
set_name(NULL, 0, cs);
1558
decimals= NOT_FIXED_DEC;
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)
1566
str_value.set_or_copy_aligned(str, length, cs);
1567
collation.set(cs, dv, repertoire);
1568
max_length= str_value.numchars()*cs->mbmaxlen;
1569
set_name(name_par, 0, cs);
1570
decimals=NOT_FIXED_DEC;
1571
// it is constant => can be used without fix_fields (and frequently used)
1575
This is used in stored procedures to avoid memory leaks and
1576
does a deep copy of its argument.
1578
void set_str_with_copy(const char *str_arg, uint length_arg)
1580
str_value.copy(str_arg, length_arg, collation.collation);
1581
max_length= str_value.numchars() * collation.collation->mbmaxlen;
1583
void set_repertoire_from_value()
1585
collation.repertoire= my_string_repertoire(str_value.charset(),
1587
str_value.length());
1589
enum Type type() const { return STRING_ITEM; }
1592
String *val_str(String*)
1595
return (String*) &str_value;
1597
my_decimal *val_decimal(my_decimal *);
1598
int save_in_field(Field *field, bool no_conversions);
1599
enum Item_result result_type () const { return STRING_RESULT; }
1600
enum_field_types field_type() const { return MYSQL_TYPE_VARCHAR; }
1601
bool basic_const_item() const { return 1; }
1602
bool eq(const Item *item, bool binary_cmp) const;
1605
return new Item_string(name, str_value.ptr(),
1606
str_value.length(), collation.collation);
1608
Item *safe_charset_converter(CHARSET_INFO *tocs);
1609
inline void append(char *str, uint length)
1611
str_value.append(str, length);
1612
max_length= str_value.numchars() * collation.collation->mbmaxlen;
1614
virtual void print(String *str, enum_query_type query_type);
1617
Return true if character-set-introducer was explicitly specified in the
1618
original query for this item (text literal).
1620
This operation is to be called from Item_string::print(). The idea is
1621
that when a query is generated (re-constructed) from the Item-tree,
1622
character-set-introducers should appear only for those literals, where
1623
they were explicitly specified by the user. Otherwise, that may lead to
1624
loss collation information (character set introducers implies default
1625
collation for the literal).
1627
Basically, that makes sense only for views and hopefully will be gone
1628
one day when we start using original query as a view definition.
1630
@return This operation returns the value of m_cs_specified attribute.
1631
@retval true if character set introducer was explicitly specified in
1633
@retval false otherwise.
1635
inline bool is_cs_specified() const
1637
return m_cs_specified;
1641
Set the value of m_cs_specified attribute.
1643
m_cs_specified attribute shows whether character-set-introducer was
1644
explicitly specified in the original query for this text literal or
1645
not. The attribute makes sense (is used) only for views.
1647
This operation is to be called from the parser during parsing an input
1650
inline void set_cs_specified(bool cs_specified)
1652
m_cs_specified= cs_specified;
1656
bool m_cs_specified;
1660
class Item_static_string_func :public Item_string
1662
const char *func_name;
1664
Item_static_string_func(const char *name_par, const char *str, uint length,
1666
Derivation dv= DERIVATION_COERCIBLE)
1667
:Item_string(NullS, str, length, cs, dv), func_name(name_par)
1669
Item *safe_charset_converter(CHARSET_INFO *tocs);
1671
virtual inline void print(String *str,
1672
enum_query_type query_type __attribute__((__unused__)))
1674
str->append(func_name);
1679
/* for show tables */
1680
class Item_return_date_time :public Item_string
1682
enum_field_types date_time_field_type;
1684
Item_return_date_time(const char *name_arg, enum_field_types field_type_arg)
1685
:Item_string(name_arg, 0, &my_charset_bin),
1686
date_time_field_type(field_type_arg)
1688
enum_field_types field_type() const { return date_time_field_type; }
1692
class Item_blob :public Item_string
1695
Item_blob(const char *name, uint length) :
1696
Item_string(name, length, &my_charset_bin)
1697
{ max_length= length; }
1698
enum Type type() const { return TYPE_HOLDER; }
1699
enum_field_types field_type() const { return MYSQL_TYPE_BLOB; }
1704
Item_empty_string -- is a utility class to put an item into List<Item>
1705
which is then used in protocol.send_fields() when sending SHOW output to
1709
class Item_empty_string :public Item_string
1712
Item_empty_string(const char *header,uint length, CHARSET_INFO *cs= NULL) :
1713
Item_string("",0, cs ? cs : &my_charset_utf8_general_ci)
1714
{ name=(char*) header; max_length= cs ? length * cs->mbmaxlen : length; }
1715
void make_field(Send_field *field);
1719
class Item_return_int :public Item_int
1721
enum_field_types int_field_type;
1723
Item_return_int(const char *name_arg, uint length,
1724
enum_field_types field_type_arg, int64_t value= 0)
1725
:Item_int(name_arg, value, length), int_field_type(field_type_arg)
1729
enum_field_types field_type() const { return int_field_type; }
1733
class Item_hex_string: public Item_basic_constant
1736
Item_hex_string() {}
1737
Item_hex_string(const char *str,uint str_length);
1738
enum Type type() const { return VARBIN_ITEM; }
1742
return (double) (uint64_t) Item_hex_string::val_int();
1745
bool basic_const_item() const { return 1; }
1746
String *val_str(String*) { assert(fixed == 1); return &str_value; }
1747
my_decimal *val_decimal(my_decimal *);
1748
int save_in_field(Field *field, bool no_conversions);
1749
enum Item_result result_type () const { return STRING_RESULT; }
1750
enum Item_result cast_to_int_type() const { return INT_RESULT; }
1751
enum_field_types field_type() const { return MYSQL_TYPE_VARCHAR; }
1752
virtual void print(String *str, enum_query_type query_type);
1753
bool eq(const Item *item, bool binary_cmp) const;
1754
virtual Item *safe_charset_converter(CHARSET_INFO *tocs);
1758
class Item_bin_string: public Item_hex_string
1761
Item_bin_string(const char *str,uint str_length);
1764
class Item_result_field :public Item /* Item with result field */
1767
Field *result_field; /* Save result here */
1768
Item_result_field() :result_field(0) {}
1769
// Constructor used for Item_sum/Item_cond_and/or (see Item comment)
1770
Item_result_field(THD *thd, Item_result_field *item):
1771
Item(thd, item), result_field(item->result_field)
1773
~Item_result_field() {} /* Required with gcc 2.95 */
1774
Field *get_tmp_table_field() { return result_field; }
1775
Field *tmp_table_field(TABLE *t_arg __attribute__((__unused__)))
1776
{ return result_field; }
1777
table_map used_tables() const { return 1; }
1778
virtual void fix_length_and_dec()=0;
1779
void set_result_field(Field *field) { result_field= field; }
1780
bool is_result_field() { return 1; }
1781
void save_in_result_field(bool no_conversions)
1783
save_in_field(result_field, no_conversions);
1789
class Item_ref :public Item_ident
1792
void set_properties();
1794
enum Ref_Type { REF, DIRECT_REF, VIEW_REF, OUTER_REF };
1795
Field *result_field; /* Save result here */
1797
Item_ref(Name_resolution_context *context_arg,
1798
const char *db_arg, const char *table_name_arg,
1799
const char *field_name_arg)
1800
:Item_ident(context_arg, db_arg, table_name_arg, field_name_arg),
1801
result_field(0), ref(0) {}
1803
This constructor is used in two scenarios:
1805
No initialization is performed, fix_fields() call will be necessary.
1807
B) *item points to an Item this Item_ref will refer to. This is
1808
used for GROUP BY. fix_fields() will not be called in this case,
1809
so we call set_properties to make this item "fixed". set_properties
1810
performs a subset of action Item_ref::fix_fields does, and this subset
1811
is enough for Item_ref's used in GROUP BY.
1813
TODO we probably fix a superset of problems like in BUG#6658. Check this
1814
with Bar, and if we have a more broader set of problems like this.
1816
Item_ref(Name_resolution_context *context_arg, Item **item,
1817
const char *table_name_arg, const char *field_name_arg,
1818
bool alias_name_used_arg= false);
1820
/* Constructor need to process subselect with temporary tables (see Item) */
1821
Item_ref(THD *thd, Item_ref *item)
1822
:Item_ident(thd, item), result_field(item->result_field), ref(item->ref) {}
1823
enum Type type() const { return REF_ITEM; }
1824
bool eq(const Item *item, bool binary_cmp) const
1826
Item *it= ((Item *) item)->real_item();
1827
return ref && (*ref)->eq(it, binary_cmp);
1831
my_decimal *val_decimal(my_decimal *);
1833
String *val_str(String* tmp);
1835
bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
1836
double val_result();
1837
int64_t val_int_result();
1838
String *str_result(String* tmp);
1839
my_decimal *val_decimal_result(my_decimal *);
1840
bool val_bool_result();
1841
bool send(Protocol *prot, String *tmp);
1842
void make_field(Send_field *field);
1843
bool fix_fields(THD *, Item **);
1844
void fix_after_pullout(st_select_lex *new_parent, Item **ref);
1845
int save_in_field(Field *field, bool no_conversions);
1846
void save_org_in_field(Field *field);
1847
enum Item_result result_type () const { return (*ref)->result_type(); }
1848
enum_field_types field_type() const { return (*ref)->field_type(); }
1849
Field *get_tmp_table_field()
1850
{ return result_field ? result_field : (*ref)->get_tmp_table_field(); }
1851
Item *get_tmp_table_item(THD *thd);
1852
table_map used_tables() const
1854
return depended_from ? OUTER_REF_TABLE_BIT : (*ref)->used_tables();
1856
void update_used_tables()
1859
(*ref)->update_used_tables();
1861
table_map not_null_tables() const { return (*ref)->not_null_tables(); }
1862
void set_result_field(Field *field) { result_field= field; }
1863
bool is_result_field() { return 1; }
1864
void save_in_result_field(bool no_conversions)
1866
(*ref)->save_in_field(result_field, no_conversions);
1870
return ref ? (*ref)->real_item() : this;
1872
bool walk(Item_processor processor, bool walk_subquery, uchar *arg)
1873
{ return (*ref)->walk(processor, walk_subquery, arg); }
1874
virtual void print(String *str, enum_query_type query_type);
1875
bool result_as_int64_t()
1877
return (*ref)->result_as_int64_t();
1880
Item_field *filed_for_view_update()
1881
{ return (*ref)->filed_for_view_update(); }
1882
virtual Ref_Type ref_type() { return REF; }
1884
// Row emulation: forwarding of ROW-related calls to ref
1887
return ref && result_type() == ROW_RESULT ? (*ref)->cols() : 1;
1889
Item* element_index(uint i)
1891
return ref && result_type() == ROW_RESULT ? (*ref)->element_index(i) : this;
1895
return ref && result_type() == ROW_RESULT ? (*ref)->addr(i) : 0;
1897
bool check_cols(uint c)
1899
return ref && result_type() == ROW_RESULT ? (*ref)->check_cols(c)
1900
: Item::check_cols(c);
1904
return ref && result_type() == ROW_RESULT ? (*ref)->null_inside() : 0;
1908
if (ref && result_type() == ROW_RESULT)
1909
(*ref)->bring_value();
1916
The same as Item_ref, but get value from val_* family of method to get
1917
value of item on which it referred instead of result* family.
1919
class Item_direct_ref :public Item_ref
1922
Item_direct_ref(Name_resolution_context *context_arg, Item **item,
1923
const char *table_name_arg,
1924
const char *field_name_arg,
1925
bool alias_name_used_arg= false)
1926
:Item_ref(context_arg, item, table_name_arg,
1927
field_name_arg, alias_name_used_arg)
1929
/* Constructor need to process subselect with temporary tables (see Item) */
1930
Item_direct_ref(THD *thd, Item_direct_ref *item) : Item_ref(thd, item) {}
1934
String *val_str(String* tmp);
1935
my_decimal *val_decimal(my_decimal *);
1938
bool get_date(MYSQL_TIME *ltime,uint fuzzydate);
1939
virtual Ref_Type ref_type() { return DIRECT_REF; }
1943
Class for view fields, the same as Item_direct_ref, but call fix_fields
1944
of reference if it is not called yet
1946
class Item_direct_view_ref :public Item_direct_ref
1949
Item_direct_view_ref(Name_resolution_context *context_arg, Item **item,
1950
const char *table_name_arg,
1951
const char *field_name_arg)
1952
:Item_direct_ref(context_arg, item, table_name_arg, field_name_arg) {}
1953
/* Constructor need to process subselect with temporary tables (see Item) */
1954
Item_direct_view_ref(THD *thd, Item_direct_ref *item)
1955
:Item_direct_ref(thd, item) {}
1957
bool fix_fields(THD *, Item **);
1958
bool eq(const Item *item, bool binary_cmp) const;
1959
Item *get_tmp_table_item(THD *thd)
1961
Item *item= Item_ref::get_tmp_table_item(thd);
1965
virtual Ref_Type ref_type() { return VIEW_REF; }
1970
Class for outer fields.
1971
An object of this class is created when the select where the outer field was
1972
resolved is a grouping one. After it has been fixed the ref field will point
1973
to either an Item_ref or an Item_direct_ref object which will be used to
1975
See also comments for the fix_inner_refs() and the
1976
Item_field::fix_outer_field() functions.
1980
class Item_outer_ref :public Item_direct_ref
1984
/* The aggregate function under which this outer ref is used, if any. */
1985
Item_sum *in_sum_func;
1987
true <=> that the outer_ref is already present in the select list
1988
of the outer select.
1990
bool found_in_select_list;
1991
Item_outer_ref(Name_resolution_context *context_arg,
1992
Item_field *outer_field_arg)
1993
:Item_direct_ref(context_arg, 0, outer_field_arg->table_name,
1994
outer_field_arg->field_name),
1995
outer_ref(outer_field_arg), in_sum_func(0),
1996
found_in_select_list(0)
2002
Item_outer_ref(Name_resolution_context *context_arg, Item **item,
2003
const char *table_name_arg, const char *field_name_arg,
2004
bool alias_name_used_arg)
2005
:Item_direct_ref(context_arg, item, table_name_arg, field_name_arg,
2006
alias_name_used_arg),
2007
outer_ref(0), in_sum_func(0), found_in_select_list(1)
2009
void save_in_result_field(bool no_conversions __attribute__((__unused__)))
2011
outer_ref->save_org_in_field(result_field);
2013
bool fix_fields(THD *, Item **);
2014
void fix_after_pullout(st_select_lex *new_parent, Item **ref);
2015
table_map used_tables() const
2017
return (*ref)->const_item() ? 0 : OUTER_REF_TABLE_BIT;
2019
virtual Ref_Type ref_type() { return OUTER_REF; }
2023
class Item_in_subselect;
2027
An object of this class:
2028
- Converts val_XXX() calls to ref->val_XXX_result() calls, like Item_ref.
2029
- Sets owner->was_null=true if it has returned a NULL value from any
2030
val_XXX() function. This allows to inject an Item_ref_null_helper
2031
object into subquery and then check if the subquery has produced a row
2035
class Item_ref_null_helper: public Item_ref
2038
Item_in_subselect* owner;
2040
Item_ref_null_helper(Name_resolution_context *context_arg,
2041
Item_in_subselect* master, Item **item,
2042
const char *table_name_arg, const char *field_name_arg)
2043
:Item_ref(context_arg, item, table_name_arg, field_name_arg),
2047
String* val_str(String* s);
2048
my_decimal *val_decimal(my_decimal *);
2050
bool get_date(MYSQL_TIME *ltime, uint fuzzydate);
2051
virtual void print(String *str, enum_query_type query_type);
2053
we add RAND_TABLE_BIT to prevent moving this item from HAVING to WHERE
2055
table_map used_tables() const
2057
return (depended_from ?
2058
OUTER_REF_TABLE_BIT :
2059
(*ref)->used_tables() | RAND_TABLE_BIT);
2064
The following class is used to optimize comparing of date and bigint columns
2065
We need to save the original item ('ref') to be able to call
2066
ref->save_in_field(). This is used to create index search keys.
2068
An instance of Item_int_with_ref may have signed or unsigned integer value.
2072
class Item_int_with_ref :public Item_int
2076
Item_int_with_ref(int64_t i, Item *ref_arg, my_bool unsigned_arg) :
2077
Item_int(i), ref(ref_arg)
2079
unsigned_flag= unsigned_arg;
2081
int save_in_field(Field *field, bool no_conversions)
2083
return ref->save_in_field(field, no_conversions);
2086
virtual Item *real_item() { return ref; }
2090
#include "item_sum.h"
2091
#include "item_func.h"
2092
#include "item_row.h"
2093
#include "item_cmpfunc.h"
2094
#include "item_strfunc.h"
2095
#include "item_timefunc.h"
2096
#include "item_subselect.h"
2099
class Item_copy_string :public Item
2101
enum enum_field_types cached_field_type;
2104
Item_copy_string(Item *i) :item(i)
2106
null_value=maybe_null=item->maybe_null;
2107
decimals=item->decimals;
2108
max_length=item->max_length;
2110
cached_field_type= item->field_type();
2112
enum Type type() const { return COPY_STR_ITEM; }
2113
enum Item_result result_type () const { return STRING_RESULT; }
2114
enum_field_types field_type() const { return cached_field_type; }
2119
return (null_value ? 0.0 :
2120
my_strntod(str_value.charset(), (char*) str_value.ptr(),
2121
str_value.length(), &end_not_used, &err_not_used));
2126
return null_value ? 0LL : my_strntoll(str_value.charset(),str_value.ptr(),
2127
str_value.length(),10, (char**) 0,
2130
String *val_str(String*);
2131
my_decimal *val_decimal(my_decimal *);
2132
void make_field(Send_field *field) { item->make_field(field); }
2134
int save_in_field(Field *field,
2135
bool no_conversions __attribute__((__unused__)))
2137
return save_str_value_in_field(field, &str_value);
2139
table_map used_tables() const { return (table_map) 1L; }
2140
bool const_item() const { return 0; }
2141
bool is_null() { return null_value; }
2145
class Cached_item :public Sql_alloc
2149
Cached_item() :null_value(0) {}
2150
virtual bool cmp(void)=0;
2151
virtual ~Cached_item(); /*line -e1509 */
2154
class Cached_item_str :public Cached_item
2157
String value,tmp_value;
2159
Cached_item_str(THD *thd, Item *arg);
2161
~Cached_item_str(); // Deallocate String:s
2165
class Cached_item_real :public Cached_item
2170
Cached_item_real(Item *item_par) :item(item_par),value(0.0) {}
2174
class Cached_item_int :public Cached_item
2179
Cached_item_int(Item *item_par) :item(item_par),value(0) {}
2184
class Cached_item_decimal :public Cached_item
2189
Cached_item_decimal(Item *item_par);
2193
class Cached_item_field :public Cached_item
2200
Cached_item_field(Field *arg_field) : field(arg_field)
2203
/* TODO: take the memory allocation below out of the constructor. */
2204
buff= (uchar*) sql_calloc(length=field->pack_length());
2209
class Item_default_value : public Item_field
2213
Item_default_value(Name_resolution_context *context_arg)
2214
:Item_field(context_arg, (const char *)NULL, (const char *)NULL,
2215
(const char *)NULL),
2217
Item_default_value(Name_resolution_context *context_arg, Item *a)
2218
:Item_field(context_arg, (const char *)NULL, (const char *)NULL,
2219
(const char *)NULL),
2221
enum Type type() const { return DEFAULT_VALUE_ITEM; }
2222
bool eq(const Item *item, bool binary_cmp) const;
2223
bool fix_fields(THD *, Item **);
2224
virtual void print(String *str, enum_query_type query_type);
2225
int save_in_field(Field *field_arg, bool no_conversions);
2226
table_map used_tables() const { return (table_map)0L; }
2228
bool walk(Item_processor processor, bool walk_subquery, uchar *args)
2230
return arg->walk(processor, walk_subquery, args) ||
2231
(this->*processor)(args);
2234
Item *transform(Item_transformer transformer, uchar *args);
2238
Item_insert_value -- an implementation of VALUES() function.
2239
You can use the VALUES(col_name) function in the UPDATE clause
2240
to refer to column values from the INSERT portion of the INSERT
2241
... UPDATE statement. In other words, VALUES(col_name) in the
2242
UPDATE clause refers to the value of col_name that would be
2243
inserted, had no duplicate-key conflict occurred.
2244
In all other places this function returns NULL.
2247
class Item_insert_value : public Item_field
2251
Item_insert_value(Name_resolution_context *context_arg, Item *a)
2252
:Item_field(context_arg, (const char *)NULL, (const char *)NULL,
2253
(const char *)NULL),
2255
bool eq(const Item *item, bool binary_cmp) const;
2256
bool fix_fields(THD *, Item **);
2257
virtual void print(String *str, enum_query_type query_type);
2258
int save_in_field(Field *field_arg, bool no_conversions)
2260
return Item_field::save_in_field(field_arg, no_conversions);
2263
We use RAND_TABLE_BIT to prevent Item_insert_value from
2264
being treated as a constant and precalculated before execution
2266
table_map used_tables() const { return RAND_TABLE_BIT; }
2268
bool walk(Item_processor processor, bool walk_subquery, uchar *args)
2270
return arg->walk(processor, walk_subquery, args) ||
2271
(this->*processor)(args);
2276
class Item_cache: public Item_basic_constant
2280
table_map used_table_map;
2282
Field that this object will get value from. This is set/used by
2283
index-based subquery engines to detect and remove the equality injected
2284
by IN->EXISTS transformation.
2285
For all other uses of Item_cache, cached_field doesn't matter.
2287
Field *cached_field;
2288
enum enum_field_types cached_field_type;
2291
example(0), used_table_map(0), cached_field(0), cached_field_type(MYSQL_TYPE_STRING)
2296
Item_cache(enum_field_types field_type_arg):
2297
example(0), used_table_map(0), cached_field(0), cached_field_type(field_type_arg)
2303
void set_used_tables(table_map map) { used_table_map= map; }
2305
virtual bool allocate(uint i __attribute__((__unused__)))
2307
virtual bool setup(Item *item)
2310
max_length= item->max_length;
2311
decimals= item->decimals;
2312
collation.set(item->collation);
2313
unsigned_flag= item->unsigned_flag;
2314
if (item->type() == FIELD_ITEM)
2315
cached_field= ((Item_field *)item)->field;
2318
virtual void store(Item *)= 0;
2319
enum Type type() const { return CACHE_ITEM; }
2320
enum_field_types field_type() const { return cached_field_type; }
2321
static Item_cache* get_cache(const Item *item);
2322
table_map used_tables() const { return used_table_map; }
2323
virtual void keep_array() {}
2324
virtual void print(String *str, enum_query_type query_type);
2325
bool eq_def(Field *field)
2327
return cached_field ? cached_field->eq_def (field) : false;
2329
bool eq(const Item *item,
2330
bool binary_cmp __attribute__((__unused__))) const
2332
return this == item;
2337
class Item_cache_int: public Item_cache
2342
Item_cache_int(): Item_cache(), value(0) {}
2343
Item_cache_int(enum_field_types field_type_arg):
2344
Item_cache(field_type_arg), value(0) {}
2346
void store(Item *item);
2347
void store(Item *item, int64_t val_arg);
2348
double val_real() { assert(fixed == 1); return (double) value; }
2349
int64_t val_int() { assert(fixed == 1); return value; }
2350
String* val_str(String *str);
2351
my_decimal *val_decimal(my_decimal *);
2352
enum Item_result result_type() const { return INT_RESULT; }
2353
bool result_as_int64_t() { return true; }
2357
class Item_cache_real: public Item_cache
2361
Item_cache_real(): Item_cache(), value(0) {}
2363
void store(Item *item);
2364
double val_real() { assert(fixed == 1); return value; }
2366
String* val_str(String *str);
2367
my_decimal *val_decimal(my_decimal *);
2368
enum Item_result result_type() const { return REAL_RESULT; }
2372
class Item_cache_decimal: public Item_cache
2375
my_decimal decimal_value;
2377
Item_cache_decimal(): Item_cache() {}
2379
void store(Item *item);
2382
String* val_str(String *str);
2383
my_decimal *val_decimal(my_decimal *);
2384
enum Item_result result_type() const { return DECIMAL_RESULT; }
2388
class Item_cache_str: public Item_cache
2390
char buffer[STRING_BUFFER_USUAL_SIZE];
2391
String *value, value_buff;
2395
Item_cache_str(const Item *item) :
2396
Item_cache(), value(0),
2397
is_varbinary(item->type() == FIELD_ITEM &&
2398
((const Item_field *) item)->field->type() ==
2399
MYSQL_TYPE_VARCHAR &&
2400
!((const Item_field *) item)->field->has_charset())
2402
void store(Item *item);
2405
String* val_str(String *) { assert(fixed == 1); return value; }
2406
my_decimal *val_decimal(my_decimal *);
2407
enum Item_result result_type() const { return STRING_RESULT; }
2408
CHARSET_INFO *charset() const { return value->charset(); };
2409
int save_in_field(Field *field, bool no_conversions);
2412
class Item_cache_row: public Item_cache
2414
Item_cache **values;
2419
:Item_cache(), values(0), item_count(2), save_array(0) {}
2422
'allocate' used only in row transformer, to preallocate space for row
2425
bool allocate(uint num);
2427
'setup' is needed only by row => it not called by simple row subselect
2428
(only by IN subselect (in subselect optimizer))
2430
bool setup(Item *item);
2431
void store(Item *item);
2432
void illegal_method_call(const char *);
2433
void make_field(Send_field *)
2435
illegal_method_call((const char*)"make_field");
2439
illegal_method_call((const char*)"val");
2444
illegal_method_call((const char*)"val_int");
2447
String *val_str(String *)
2449
illegal_method_call((const char*)"val_str");
2452
my_decimal *val_decimal(my_decimal *val __attribute__((__unused__)))
2454
illegal_method_call((const char*)"val_decimal");
2458
enum Item_result result_type() const { return ROW_RESULT; }
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);
2466
void keep_array() { save_array= 1; }
2469
Item_cache::cleanup();
2471
bzero(values, item_count*sizeof(Item**));
2480
Item_type_holder used to store type. name, length of Item for UNIONS &
2483
Item_type_holder do not need cleanup() because its time of live limited by
2484
single SP/PS execution.
2486
class Item_type_holder: public Item
2489
TYPELIB *enum_set_typelib;
2490
enum_field_types fld_type;
2492
void get_full_info(Item *item);
2494
/* It is used to count decimal precision in join_types */
2495
int prev_decimal_int_part;
2497
Item_type_holder(THD*, Item*);
2499
Item_result result_type() const;
2500
enum_field_types field_type() const { return fld_type; };
2501
enum Type type() const { return TYPE_HOLDER; }
2504
my_decimal *val_decimal(my_decimal *);
2505
String *val_str(String*);
2506
bool join_types(THD *thd, Item *);
2507
Field *make_field_by_type(TABLE *table);
2508
static uint32 display_length(Item *item);
2509
static enum_field_types get_real_type(Item *);
2513
class st_select_lex;
2514
void mark_select_range_as_dependent(THD *thd,
627
2515
st_select_lex *last_select,
628
2516
st_select_lex *current_sel,
629
2517
Field *found_field, Item *found_item,
630
2518
Item_ident *resolved_item);
632
extern void resolve_const_item(Session *session, Item **ref, Item *cmp_item);
2520
extern Cached_item *new_Cached_item(THD *thd, Item *item,
2521
bool use_result_field);
2522
extern void resolve_const_item(THD *thd, Item **ref, Item *cmp_item);
633
2523
extern bool field_is_equal_to_item(Field *field,Item *item);
636
Create field for temporary table.
638
@param session Thread handler
639
@param table Temporary table
640
@param item Item to create a field for
641
@param type Type of item (normally item->type)
642
@param copy_func If set and item is a function, store copy of item
644
@param from_field if field will be created using other field as example,
645
pointer example field will be written here
646
@param default_field If field has a default value field, store it here
647
@param group 1 if we are going to do a relative group by on result
648
@param modify_item 1 if item->result_field should point to new item.
649
This is relevent for how fill_record() is going to
651
If modify_item is 1 then fill_record() will update
652
the record in the original table.
653
If modify_item is 0 then fill_record() will update
655
@param convert_blob_length If >0 create a varstring(convert_blob_length)
656
field instead of blob.
664
/* TODO: This is here for now because it needs the Item::Type. It should live
665
in Field or Table once item.h is clean enough to actually include */
666
Field *create_tmp_field(Session *session, Table *table, Item *item,
668
Item ***copy_func, Field **from_field,
670
bool group, bool modify_item,
671
bool table_cant_handle_bit_fields,
672
bool make_copy_field,
673
uint32_t convert_blob_length);
675
#endif /* DRIZZLED_ITEM_H */
added
removed
server/item.h
