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 <drizzled/drizzle_time.h>
25
#include <drizzled/decimal.h>
26
#include <drizzled/sql_bitmap.h>
27
#include <drizzled/sql_list.h>
28
#include "drizzled/memory/sql_alloc.h"
29
#include <drizzled/table.h>
30
#include "drizzled/item_result.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 */
37
class Name_resolution_context;
42
class Item_in_subselect;
52
Dummy error processor used by default by Name_resolution_context.
57
void dummy_error_processor(Session *session, void *data);
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_t 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_t 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_t 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);
62
419
argp in/out IN: Analysis parameter
63
420
OUT: Parameter to be passed to the transformer
66
423
true Invoke the transformer
70
typedef bool (Item::*Item_analyzer) (unsigned char **argp);
71
typedef Item* (Item::*Item_transformer) (unsigned char *arg);
427
typedef bool (Item::*Item_analyzer) (uchar **argp);
428
typedef Item* (Item::*Item_transformer) (uchar *arg);
72
429
typedef void (*Cond_traverser) (const Item *item, void *arg);
73
typedef bool (Item::*Item_processor) (unsigned char *arg);
76
* The Item class is the base class for all items in the parsed
77
* statement "tree" or Lex. Each item represents something in the
80
class Item: public memory::SqlAlloc
82
/* Prevent use of these */
434
Item(const Item &); /* Prevent use of these */
84
435
void operator=(Item &);
86
436
/* Cache of the result of is_expensive(). */
87
437
int8_t is_expensive_cache;
88
virtual bool is_expensive_processor(unsigned char *arg);
438
virtual bool is_expensive_processor(uchar *arg __attribute__((unused)))
112
ROW_ITEM, CACHE_ITEM,
131
* str_values's main purpose is to be used to cache the value in
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)))
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,
463
enum cond_result { COND_UNDEF,COND_OK,COND_TRUE,COND_FALSE };
465
enum traverse_order { POSTFIX, PREFIX };
467
/* Reuse size, only used by SP local variable assignment, otherwize 0 */
471
str_values's main purpose is to be used to cache the value in
134
474
String str_value;
136
/** Name from select */
138
/** Length of name */
139
uint32_t name_length;
141
/** Original item name (if it was renamed) */
475
char * name; /* Name from select */
476
/* Original item name (if it was renamed)*/
144
479
uint32_t max_length;
480
uint name_length; /* Length of name */
147
482
uint8_t decimals;
148
bool fixed; /**< If item fixed with fix_fields */
149
bool maybe_null; /**< True if item may be null */
150
bool null_value; /**< True if item is null */
153
bool is_autogenerated_name; /**< indicates whether name of this Item was autogenerated or set by user */
155
* If this item is a subselect or some of its arguments is or contains a
156
* subselect. Computed by fix_fields.
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
489
autogenerated or set by user */
159
490
DTCollation collation;
160
Item_result cmp_context; /**< Comparison context */
166
* Alloc & destruct is done as start of select using memory::sql_alloc
491
my_bool with_subselect; /* If this item is a subselect or some
492
of its arguments is or contains a
493
subselect. Computed by fix_fields. */
494
Item_result cmp_context; /* Comparison context */
495
// alloc & destruct is done as start of select using sql_alloc
170
* Constructor used by Item_field, Item_ref & aggregate (sum) functions.
172
* Used for duplicating lists in processing queries with temporary
175
* Also it used for Item_cond_and/Item_cond_or for creating
176
* top AND/OR structure of WHERE clause to protect it of
177
* optimisation changes in prepared statements
179
Item(Session *session, Item *item);
498
Constructor used by Item_field, Item_ref & aggregate (sum) functions.
499
Used for duplicating lists in processing queries with temporary
501
Also it used for Item_cond_and/Item_cond_or for creating
502
top AND/OR structure of WHERE clause to protect it of
503
optimisation changes in prepared statements
505
Item(THD *thd, Item *item);
182
508
#ifdef EXTRA_DEBUG
187
void set_name(const std::string &arg)
189
set_name(arg.c_str(), arg.length(), system_charset_info);
192
void set_name(const char *str, uint32_t length, const CHARSET_INFO * const cs= system_charset_info);
194
* Renames item (used for views, cleanup() return original name).
196
* @param new_name new name of item;
512
void set_name(const char *str, uint length, CHARSET_INFO *cs);
198
513
void rename(char *new_name);
199
void init_make_field(SendField *tmp_field,enum enum_field_types type);
514
void init_make_field(Send_field *tmp_field,enum enum_field_types type);
200
515
virtual void cleanup();
201
virtual void make_field(SendField *field);
203
Create a field to hold a string value from an item.
205
If max_length > CONVERT_IF_BIGGER_TO_BLOB create a blob @n
206
If max_length > 0 create a varchar @n
207
If max_length == 0 create a CHAR(0)
209
@param table Table for which the field is created
211
Field *make_string_field(Table *table);
212
virtual bool fix_fields(Session *, Item **);
215
* Fix after some tables has been pulled out. Basically re-calculate all
216
* attributes that are dependent on the tables.
218
virtual void fix_after_pullout(Select_Lex *new_parent, Item **ref);
221
* Should be used in case where we are sure that we do not need
222
* complete fix_fields() procedure.
224
inline void quick_fix_field()
516
virtual void make_field(Send_field *field);
517
Field *make_string_field(TABLE *table);
518
virtual bool fix_fields(THD *, Item **);
520
Fix after some tables has been pulled out. Basically re-calculate all
521
attributes that are dependent on the tables.
523
virtual void fix_after_pullout(st_select_lex *new_parent __attribute__((unused)),
524
Item **ref __attribute__((unused))) {};
527
should be used in case where we are sure that we do not need
528
complete fix_fields() procedure.
530
inline void quick_fix_field() { fixed= 1; }
531
/* Function returns 1 on overflow and -1 on fatal errors */
532
int save_in_field_no_warnings(Field *field, bool no_conversions);
229
533
virtual int save_in_field(Field *field, bool no_conversions);
230
534
virtual void save_org_in_field(Field *field)
232
(void) save_in_field(field, true);
535
{ (void) save_in_field(field, 1); }
234
536
virtual int save_safe_in_field(Field *field)
236
return save_in_field(field, true);
239
* This is only called from items that is not of type item_field.
241
virtual bool send(plugin::Client *client, String *str);
243
Compares this Item to another Item, returning true if Item's
244
are functionally equal.
248
This function is called when:
249
- Comparing items in the WHERE clause (when doing where optimization)
250
- When trying to find an order_st BY/GROUP BY item in the SELECT part
537
{ return save_in_field(field, 1); }
538
virtual bool send(Protocol *protocol, String *str);
252
539
virtual bool eq(const Item *, bool binary_cmp) const;
253
virtual Item_result result_type() const
257
virtual Item_result cast_to_int_type() const
259
return result_type();
540
virtual Item_result result_type() const { return REAL_RESULT; }
541
virtual Item_result cast_to_int_type() const { return result_type(); }
261
542
virtual enum_field_types string_field_type() const;
262
543
virtual enum_field_types field_type() const;
263
544
virtual enum Type type() const =0;
267
* "func_arg $CMP$ const" half-interval
269
* "FUNC(func_arg) $CMP2$ const2"
273
* left_endp false <=> The interval is "x < const" or "x <= const"
274
* true <=> The interval is "x > const" or "x >= const"
276
* incl_endp IN true <=> the comparison is '<' or '>'
277
* false <=> the comparison is '<=' or '>='
278
* OUT The same but for the "F(x) $CMP$ F(const)" comparison
280
* This function is defined only for unary monotonic functions. The caller
281
* supplies the source half-interval
285
* The value of const is supplied implicitly as the value this item's
286
* argument, the form of $CMP$ comparison is specified through the
287
* function's arguments. The calle returns the result interval
289
* F(x) $CMP2$ F(const)
291
* passing back F(const) as the return value, and the form of $CMP2$
292
* through the out parameter. NULL values are assumed to be comparable and
293
* be less than any non-NULL values.
297
* The output range bound, which equal to the value of val_int()
298
* - If the value of the function is NULL then the bound is the
299
* smallest possible value of INT64_MIN
301
virtual int64_t val_int_endpoint(bool left_endp, bool *incl_endp);
547
Return information about function monotonicity. See comment for
548
enum_monotonicity_info for details. This function can only be called
549
after fix_fields() call.
551
virtual enum_monotonicity_info get_monotonicity_info() const
552
{ return NON_MONOTONIC; }
555
Convert "func_arg $CMP$ const" half-interval into "FUNC(func_arg) $CMP2$ const2"
559
left_endp false <=> The interval is "x < const" or "x <= const"
560
true <=> The interval is "x > const" or "x >= const"
562
incl_endp IN true <=> the comparison is '<' or '>'
563
false <=> the comparison is '<=' or '>='
564
OUT The same but for the "F(x) $CMP$ F(const)" comparison
567
This function is defined only for unary monotonic functions. The caller
568
supplies the source half-interval
572
The value of const is supplied implicitly as the value this item's
573
argument, the form of $CMP$ comparison is specified through the
574
function's arguments. The calle returns the result interval
578
passing back F(const) as the return value, and the form of $CMP2$
579
through the out parameter. NULL values are assumed to be comparable and
580
be less than any non-NULL values.
583
The output range bound, which equal to the value of val_int()
584
- If the value of the function is NULL then the bound is the
585
smallest possible value of INT64_MIN
587
virtual int64_t val_int_endpoint(bool left_endp __attribute__((unused)),
588
bool *incl_endp __attribute__((unused)))
589
{ assert(0); return 0; }
303
592
/* valXXX methods must return NULL or 0 or 0.0 if null_value is set. */
305
* Returns double precision floating point representation of item.
309
* In case of NULL value return 0.0 and set null_value flag to true.
310
* If value is not null null_value flag will be reset to false.
594
Return double precision floating point representation of item.
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.
312
603
virtual double val_real()=0;
314
* Returns integer representation of item.
318
* In case of NULL value return 0 and set null_value flag to true.
319
* If value is not null null_value flag will be reset to false.
605
Return integer representation of item.
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.
321
614
virtual int64_t val_int()=0;
323
* This is just a shortcut to avoid the cast. You should still use
324
* unsigned_flag to check the sign of the item.
326
inline uint64_t val_uint()
328
return (uint64_t) val_int();
331
* Return string representation of this item object.
333
* @param an allocated buffer this or any nested Item object can use to
334
* store return value of this method.
338
* Buffer passed via argument should only be used if the item itself
339
* doesn't have an own String buffer. In case when the item maintains
340
* it's own string buffer, it's preferable to return it instead to
341
* minimize number of mallocs/memcpys.
343
* The caller of this method can modify returned string, but only in case
344
* when it was allocated on heap, (is_alloced() is true). This allows
345
* the caller to efficiently use a buffer allocated by a child without
346
* having to allocate a buffer of it's own. The buffer, given to
347
* val_str() as argument, belongs to the caller and is later used by the
348
* caller at it's own choosing.
350
* A few implications from the above:
351
* - unless you return a string object which only points to your buffer
352
* but doesn't manages it you should be ready that it will be
354
* - even for not allocated strings (is_alloced() == false) the caller
355
* can change charset (see Item_func_{typecast/binary}. XXX: is this
357
* - still you should try to minimize data copying and return internal
358
* object whenever possible.
361
* In case of NULL value return 0 (NULL pointer) and set null_value flag
363
* If value is not null null_value flag will be reset to false.
616
This is just a shortcut to avoid the cast. You should still use
617
unsigned_flag to check the sign of the item.
619
inline uint64_t val_uint() { return (uint64_t) val_int(); }
621
Return string representation of this item object.
625
str an allocated buffer this or any nested Item object can use to
626
store return value of this method.
629
Buffer passed via argument should only be used if the item itself
630
doesn't have an own String buffer. In case when the item maintains
631
it's own string buffer, it's preferable to return it instead to
632
minimize number of mallocs/memcpys.
633
The caller of this method can modify returned string, but only in case
634
when it was allocated on heap, (is_alloced() is true). This allows
635
the caller to efficiently use a buffer allocated by a child without
636
having to allocate a buffer of it's own. The buffer, given to
637
val_str() as argument, belongs to the caller and is later used by the
638
caller at it's own choosing.
639
A few implications from the above:
640
- unless you return a string object which only points to your buffer
641
but doesn't manages it you should be ready that it will be
643
- even for not allocated strings (is_alloced() == false) the caller
644
can change charset (see Item_func_{typecast/binary}. XXX: is this
646
- still you should try to minimize data copying and return internal
647
object whenever possible.
650
In case of NULL value return 0 (NULL pointer) and set null_value flag
652
If value is not null null_value flag will be reset to false.
365
654
virtual String *val_str(String *str)=0;
367
* Return decimal representation of item with fixed point.
369
* @param buffer which can be used by Item for returning value
374
* Returned value should not be changed if it is not the same which was
375
* passed via argument.
379
* Return pointer on my_decimal (it can be other then passed via argument)
380
* if value is not NULL (null_value flag will be reset to false).
381
* In case of NULL value it return 0 pointer and set null_value flag
656
Return decimal representation of item with fixed point.
660
decimal_buffer buffer which can be used by Item for returning value
664
Returned value should not be changed if it is not the same which was
668
Return pointer on my_decimal (it can be other then passed via argument)
669
if value is not NULL (null_value flag will be reset to false).
670
In case of NULL value it return 0 pointer and set null_value flag
384
673
virtual my_decimal *val_decimal(my_decimal *decimal_buffer)= 0;
386
* Return boolean value of item.
390
* false value is false or NULL
391
* true value is true (not equal to 0)
675
Return boolean value of item.
678
false value is false or NULL
679
true value is true (not equal to 0)
393
681
virtual bool val_bool();
682
virtual String *val_nodeset(String*) { return 0; }
394
683
/* Helper functions, see item_sum.cc */
395
684
String *val_string_from_real(String *str);
396
685
String *val_string_from_int(String *str);
529
765
query and why they should be generated from the Item-tree, @see
530
766
mysql_register_view().
532
virtual void print(String *str, enum_query_type query_type);
768
virtual inline void print(String *str,
769
enum_query_type query_type __attribute__((unused)))
771
str->append(full_name());
534
774
void print_item_w_name(String *, enum_query_type query_type);
535
775
virtual void update_used_tables() {}
536
virtual void split_sum_func(Session *session,
537
Item **ref_pointer_array,
540
Move SUM items out from item tree and replace with reference.
542
@param session Thread handler
543
@param ref_pointer_array Pointer to array of reference fields
544
@param fields All fields in select
545
@param ref Pointer to item
546
@param skip_registered <=> function be must skipped for registered
550
This is from split_sum_func() for items that should be split
552
All found SUM items are added FIRST in the fields list and
553
we replace the item with a reference.
555
session->fatal_error() may be called if we are out of memory
557
void split_sum_func(Session *session,
558
Item **ref_pointer_array,
561
bool skip_registered);
564
Get the value of the function as a DRIZZLE_TIME structure.
565
As a extra convenience the time structure is reset on error!
567
virtual bool get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate);
569
Get time of first argument.
571
As a extra convenience the time structure is reset on error!
776
virtual void split_sum_func(THD *thd __attribute__((unused)),
777
Item **ref_pointer_array __attribute__((unused)),
778
List<Item> &fields __attribute__((unused))) {}
779
/* Called for items that really have to be split */
780
void split_sum_func2(THD *thd, Item **ref_pointer_array, List<Item> &fields,
781
Item **ref, bool skip_registered);
782
virtual bool get_date(DRIZZLE_TIME *ltime,uint fuzzydate);
573
783
virtual bool get_time(DRIZZLE_TIME *ltime);
574
virtual bool get_date_result(DRIZZLE_TIME *ltime,uint32_t fuzzydate);
577
The method allows to determine nullness of a complex expression
578
without fully evaluating it, instead of calling val/result*() then
784
virtual bool get_date_result(DRIZZLE_TIME *ltime,uint fuzzydate)
785
{ return get_date(ltime,fuzzydate); }
787
The method allows to determine nullness of a complex expression
788
without fully evaluating it, instead of calling val/result*() then
579
789
checking null_value. Used in Item_func_isnull/Item_func_isnotnull
580
790
and Item_sum_count/Item_sum_count_distinct.
581
791
Any new item which can be NULL must implement this method.
583
virtual bool is_null();
585
/** Make sure the null_value member has a correct value. */
586
virtual void update_null_value ();
793
virtual bool is_null() { return 0; }
796
Make sure the null_value member has a correct value.
798
virtual void update_null_value () { (void) val_int(); }
589
801
Inform the item that there will be no distinction between its result
590
802
being false or NULL.
594
805
This function will be called for eg. Items that are top-level AND-parts
595
806
of the WHERE clause. Items implementing this function (currently
596
807
Item_cond_and and subquery-related item) enable special optimizations
597
808
when they are "top level".
599
virtual void top_level_item(void);
601
* Sets field of temporary table for Item which can be switched on temporary
602
* table during query processing (grouping and so on)
604
virtual void set_result_field(Field *field);
605
virtual bool is_result_field(void);
606
virtual bool is_bool_func(void);
607
virtual void save_in_result_field(bool no_conversions);
610
* Sets value of aggregate function in case of no rows for grouping were found
612
virtual void no_rows_in_result(void);
613
virtual Item *copy_or_same(Session *session);
615
virtual Item *copy_andor_structure(Session *session);
617
virtual Item *real_item(void);
618
virtual const Item *real_item(void) const;
619
virtual Item *get_tmp_table_item(Session *session);
621
static const CHARSET_INFO *default_charset();
622
virtual const CHARSET_INFO *compare_collation();
624
virtual bool walk(Item_processor processor,
629
Traverse item tree possibly transforming it (replacing items).
631
If you don't need to transform an item tree, but only traverse
632
it, please use Item::walk() instead.
634
@param transformer functor that performs transformation of a subtree
635
@param arg opaque argument passed to the functor
638
Returns pointer to the new subtree root. Session::change_item_tree()
639
should be called for it if transformation took place, i.e. if a
640
pointer to newly allocated item is returned.
642
virtual Item* transform(Item_transformer transformer, unsigned char *arg);
810
virtual void top_level_item(void) {}
812
set field of temporary table for Item which can be switched on temporary
813
table during query processing (grouping and so on)
815
virtual void set_result_field(Field *field __attribute__((unused))) {}
816
virtual bool is_result_field(void) { return 0; }
817
virtual bool is_bool_func(void) { return 0; }
818
virtual void save_in_result_field(bool no_conversions __attribute__((unused)))
821
set value of aggregate function in case of no rows for grouping were found
823
virtual void no_rows_in_result(void) {}
824
virtual Item *copy_or_same(THD *thd __attribute__((unused)))
826
virtual Item *copy_andor_structure(THD *thd __attribute__((unused)))
828
virtual Item *real_item(void) { return this; }
829
virtual Item *get_tmp_table_item(THD *thd) { return copy_or_same(thd); }
831
static CHARSET_INFO *default_charset();
832
virtual CHARSET_INFO *compare_collation() { return NULL; }
834
virtual bool walk(Item_processor processor __attribute__((unused)),
835
bool walk_subquery __attribute__((unused)),
838
return (this->*processor)(arg);
841
virtual Item* transform(Item_transformer transformer, uchar *arg);
645
844
This function performs a generic "compilation" of the Item tree.
646
The process of compilation is assumed to go as follows:
845
The process of compilation is assumed to go as follows:
651
849
if (this->*some_analyzer(...))
653
851
compile children if any;
654
852
this->*some_transformer(...);
659
856
i.e. analysis is performed top-down while transformation is done
662
virtual Item* compile(Item_analyzer analyzer,
663
unsigned char **arg_p,
664
Item_transformer transformer,
665
unsigned char *arg_t);
667
virtual void traverse_cond(Cond_traverser traverser,
669
traverse_order order);
671
virtual bool remove_dependence_processor(unsigned char * arg);
672
virtual bool remove_fixed(unsigned char * arg);
673
virtual bool collect_item_field_processor(unsigned char * arg);
674
virtual bool find_item_in_field_list_processor(unsigned char *arg);
675
virtual bool change_context_processor(unsigned char *context);
676
virtual bool register_field_in_read_map(unsigned char *arg);
677
virtual bool subst_argument_checker(unsigned char **arg);
679
virtual bool cache_const_expr_analyzer(unsigned char **arg);
680
virtual Item* cache_const_expr_transformer(unsigned char *arg);
682
virtual Item *equal_fields_propagator(unsigned char * arg);
683
virtual bool set_no_const_sub(unsigned char *arg);
684
virtual Item *replace_equal_field(unsigned char * arg);
859
virtual Item* compile(Item_analyzer analyzer, uchar **arg_p,
860
Item_transformer transformer, uchar *arg_t)
862
if ((this->*analyzer) (arg_p))
863
return ((this->*transformer) (arg_t));
867
virtual void traverse_cond(Cond_traverser traverser __attribute__((unused)),
869
traverse_order order __attribute__((unused)))
871
(*traverser)(this, arg);
874
virtual bool remove_dependence_processor(uchar * arg __attribute__((unused)))
876
virtual bool remove_fixed(uchar * arg __attribute__((unused)))
881
virtual bool cleanup_processor(uchar *arg __attribute__((unused)));
882
virtual bool collect_item_field_processor(uchar * arg __attribute__((unused)))
884
virtual bool find_item_in_field_list_processor(uchar *arg __attribute__((unused)))
886
virtual bool change_context_processor(uchar *context __attribute__((unused)))
888
virtual bool reset_query_id_processor(uchar *query_id_arg __attribute__((unused)))
890
virtual bool register_field_in_read_map(uchar *arg __attribute__((unused)))
892
virtual bool subst_argument_checker(uchar **arg)
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; }
904
For SP local variable returns pointer to Item representing its
905
current value and pointer to current Item otherwise.
907
virtual Item *this_item(void) { return this; }
908
virtual const Item *this_item(void) const { return this; }
911
For SP local variable returns address of pointer to Item representing its
912
current value and pointer passed via parameter otherwise.
914
virtual Item **this_item_addr(THD *thd __attribute__((unused)), Item **addr_arg) { return addr_arg; }
687
virtual uint32_t cols();
688
virtual Item* element_index(uint32_t i);
689
virtual Item** addr(uint32_t i);
690
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);
691
921
// It is not row => null inside is impossible
692
virtual bool null_inside();
922
virtual bool null_inside() { return 0; }
693
923
// used in row subselects to get value of elements
694
virtual void bring_value();
697
Create a field based on field_type of argument.
699
For now, this is only used to create a field for
700
IFNULL(x,something) and time functions
924
virtual void bring_value() {}
926
Field *tmp_table_field_from_field_type(TABLE *table, bool fixed_length);
927
virtual Item_field *filed_for_view_update() { return 0; }
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);
939
result_as_int64_t() must return true for Items representing DATE/TIME
940
functions and DATE/TIME table fields.
941
Those Items have result_type()==STRING_RESULT (and not INT_RESULT), but
942
their values should be compared as integers (because the integer
943
representation is more precise than the string one).
707
Field *tmp_table_field_from_field_type(Table *table, bool fixed_length);
709
virtual Item *neg_transformer(Session *session);
710
virtual Item *update_value_transformer(unsigned char *select_arg);
711
virtual Item *safe_charset_converter(const CHARSET_INFO * const tocs);
715
* Returns true for Items representing DATE/TIME functions and DATE/TIME table fields.
716
* Those Items have result_type()==STRING_RESULT (and not INT_RESULT), but
717
* their values should be compared as integers (because the integer
718
* representation is more precise than the string one).
720
virtual bool result_as_int64_t();
945
virtual bool result_as_int64_t() { return false; }
721
946
bool is_datetime();
724
* Tests whether an expression is expensive to compute. Used during
725
* optimization to avoid computing expensive expressions during this
726
* phase. Also used to force temp tables when sorting on expensive
731
* Normally we should have a method:
732
* cost Item::execution_cost(),
733
* where 'cost' is either 'double' or some structure of various cost
737
* This function is now used to prevent evaluation of materialized IN
738
* subquery predicates before it is allowed. grep for
739
* DontEvaluateMaterializedSubqueryTooEarly to see the uses.
741
virtual bool is_expensive();
949
Test whether an expression is expensive to compute. Used during
950
optimization to avoid computing expensive expressions during this
951
phase. Also used to force temp tables when sorting on expensive
954
Normally we should have a method:
955
cost Item::execution_cost(),
956
where 'cost' is either 'double' or some structure of various cost
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);
743
965
String *check_well_formed_result(String *str, bool send_error= 0);
745
* Compares two items using a given collation
749
* This method works exactly as Item::eq if the collation cs coincides with
750
* the collation of the compared objects. Otherwise, first the collations that
751
* differ from cs are replaced for cs and then the items are compared by
752
* Item::eq. After the comparison the original collations of items are
755
* @param Pointer to the item to compare with
756
* @param Compare as binary?
757
* @param Pointer to the collation to use when comparing strings
760
* true if compared items has been detected as equal
764
bool eq_by_collation(Item *item, bool binary_cmp, const CHARSET_INFO * const cs);
767
} /* namespace drizzled */
769
/** @TODO Why is this in the middle? */
770
#include <drizzled/item/ident.h>
776
Mark item and Select_Lexs as dependent if item was resolved in
779
@param session thread handler
780
@param last select from which current item depend
781
@param current current select
782
@param resolved_item item which was resolved in outer SELECT(for warning)
783
@param mark_item item which should be marked (can be differ in case of
786
void mark_as_dependent(Session *session,
789
Item_ident *resolved_item,
790
Item_ident *mark_item);
793
Resolve a column reference in a sub-select.
795
Resolve a column reference (usually inside a HAVING clause) against the
796
SELECT and GROUP BY clauses of the query described by 'select'. The name
797
resolution algorithm searches both the SELECT and GROUP BY clauses, and in
798
case of a name conflict prefers GROUP BY column names over SELECT names. If
799
both clauses contain different fields with the same names, a warning is
800
issued that name of 'ref' is ambiguous. We extend ANSI SQL in that when no
801
GROUP BY column is found, then a HAVING name is resolved as a possibly
802
derived SELECT column. This extension is allowed only if the
803
MODE_ONLY_FULL_GROUP_BY sql mode isn't enabled.
805
@param session current thread
806
@param ref column reference being resolved
807
@param select the select that ref is resolved against
810
The resolution procedure is:
811
- Search for a column or derived column named col_ref_i [in table T_j]
812
in the SELECT clause of Q.
813
- Search for a column named col_ref_i [in table T_j]
814
in the GROUP BY clause of Q.
815
- If found different columns with the same name in GROUP BY and SELECT
816
- issue a warning and return the GROUP BY column,
818
- if the MODE_ONLY_FULL_GROUP_BY mode is enabled return error
819
- else return the found SELECT column.
823
- NULL - there was an error, and the error was already reported
824
- not_found_item - the item was not resolved, no error was reported
825
- resolved item - if the item was resolved
827
Item** resolve_ref_in_select_and_group(Session *session, Item_ident *ref, Select_Lex *select);
830
Mark range of selects and resolved identifier (field/reference)
833
@param session thread handler
834
@param last_select select where resolved_item was resolved
835
@param current_sel current select (select where resolved_item was placed)
836
@param found_field field which was found during resolving
837
@param found_item Item which was found during resolving (if resolved
838
identifier belongs to VIEW)
839
@param resolved_item Identifier which was resolved
842
We have to mark all items between current_sel (including) and
843
last_select (excluding) as dependend (select before last_select should
844
be marked with actual table mask used by resolved item, all other with
845
OUTER_REF_TABLE_BIT) and also write dependence information to Item of
848
void mark_select_range_as_dependent(Session *session,
849
Select_Lex *last_select,
850
Select_Lex *current_sel,
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(DRIZZLE_TIME *ltime,uint fuzzydate);
1151
bool get_date_result(DRIZZLE_TIME *ltime,uint fuzzydate);
1152
bool get_time(DRIZZLE_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_t 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 DRIZZLE_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 DRIZZLE_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(DRIZZLE_TIME *tm);
1311
bool get_date(DRIZZLE_TIME *tm, uint fuzzydate);
1312
int save_in_field(Field *field, bool no_conversions);
1315
void set_int(int64_t i, uint32_t 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(DRIZZLE_TIME *tm, timestamp_type type, uint32_t 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_t 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 DRIZZLE_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 DRIZZLE_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_t) decimal_par;
1476
Item_float(double value_par, uint decimal_par) :presentation(0), value(value_par)
1478
decimals= (uint8_t) 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 DRIZZLE_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 DRIZZLE_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 DRIZZLE_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 DRIZZLE_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(DRIZZLE_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(DRIZZLE_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(DRIZZLE_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(DRIZZLE_TYPE_VARCHAR)
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
DRIZZLE_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
memset(values, 0, 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_t 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,
2515
st_select_lex *last_select,
2516
st_select_lex *current_sel,
851
2517
Field *found_field, Item *found_item,
852
2518
Item_ident *resolved_item);
854
extern void resolve_const_item(Session *session, Item **ref, Item *cmp_item);
856
Return true if the value stored in the field is equal to the const
859
We need to use this on the range optimizer because in some cases
860
we can't store the value in the field without some precision/character loss.
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);
862
2523
extern bool field_is_equal_to_item(Field *field,Item *item);
865
Create field for temporary table.
869
This is here for now because it needs the Item::Type. It should live
870
in Field or Table once item.h is clean enough to actually include
872
@param session Thread handler
873
@param table Temporary table
874
@param item Item to create a field for
875
@param type Type of item (normally item->type)
876
@param copy_func If set and item is a function, store copy of item
878
@param from_field if field will be created using other field as example,
879
pointer example field will be written here
880
@param default_field If field has a default value field, store it here
881
@param group 1 if we are going to do a relative group by on result
882
@param modify_item 1 if item->result_field should point to new item.
883
This is relevent for how fill_record() is going to
885
If modify_item is 1 then fill_record() will update
886
the record in the original table.
887
If modify_item is 0 then fill_record() will update
889
@param convert_blob_length If >0 create a varstring(convert_blob_length)
890
field instead of blob.
897
Field *create_tmp_field(Session *session,
906
bool make_copy_field,
907
uint32_t convert_blob_length);
909
} /* namespace drizzled */
911
#endif /* DRIZZLED_ITEM_H */
added
removed
drizzled/item.h
