← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item.cc

pandora-build v0.71. Added check for avahi.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item.cc
1
 
/* Copyright (C) 2000-2006 MySQL AB
2
 
 
3
 
   This program is free software; you can redistribute it and/or modify
4
 
   it under the terms of the GNU General Public License as published by
5
 
   the Free Software Foundation; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
 
 
16
 
 
17
 
#include <drizzled/server_includes.h>
18
 
#include <drizzled/sql_select.h>
19
 
#include <drizzled/drizzled_error_messages.h>
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008-2009 Sun Microsystems
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; version 2 of the License.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
18
 */
 
19
 
 
20
#include "drizzled/server_includes.h"
 
21
#include "drizzled/sql_select.h"
 
22
#include "drizzled/error.h"
 
23
#include "drizzled/show.h"
 
24
#include "drizzled/item/cmpfunc.h"
 
25
#include "drizzled/item/cache_row.h"
 
26
#include "drizzled/item/type_holder.h"
 
27
#include "drizzled/item/sum.h"
 
28
#include "drizzled/item/copy_string.h"
 
29
#include "drizzled/function/str/conv_charset.h"
 
30
#include "drizzled/sql_base.h"
 
31
#include "drizzled/util/convert.h"
 
32
#include "drizzled/plugin/client.h"
 
33
 
 
34
#include "drizzled/field/str.h"
 
35
#include "drizzled/field/num.h"
 
36
#include "drizzled/field/blob.h"
 
37
#include "drizzled/field/enum.h"
 
38
#include "drizzled/field/null.h"
 
39
#include "drizzled/field/date.h"
 
40
#include "drizzled/field/decimal.h"
 
41
#include "drizzled/field/real.h"
 
42
#include "drizzled/field/double.h"
 
43
#include "drizzled/field/long.h"
 
44
#include "drizzled/field/int64_t.h"
 
45
#include "drizzled/field/num.h"
 
46
#include "drizzled/field/timestamp.h"
 
47
#include "drizzled/field/datetime.h"
 
48
#include "drizzled/field/varstring.h"
 
49
 
 
50
#include <math.h>
 
51
#include <algorithm>
 
52
 
 
53
using namespace std;
 
54
using namespace drizzled;
20
55
 
21
56
const String my_null_string("NULL", 4, default_charset_info);
22
57
 
23
 
/****************************************************************************/
24
 
 
25
 
/* Hybrid_type_traits {_real} */
26
 
 
27
 
void Hybrid_type_traits::fix_length_and_dec(Item *item, Item *arg) const
28
 
{
29
 
  item->decimals= NOT_FIXED_DEC;
30
 
  item->max_length= item->float_length(arg->decimals);
31
 
}
32
 
 
33
 
static const Hybrid_type_traits real_traits_instance;
34
 
 
35
 
const Hybrid_type_traits *Hybrid_type_traits::instance()
36
 
{
37
 
  return &real_traits_instance;
38
 
}
39
 
 
40
 
 
41
 
my_decimal *
42
 
Hybrid_type_traits::val_decimal(Hybrid_type *val,
43
 
                                my_decimal *to __attribute__((unused))) const
44
 
{
45
 
  double2my_decimal(E_DEC_FATAL_ERROR, val->real, val->dec_buf);
46
 
  return val->dec_buf;
47
 
}
48
 
 
49
 
 
50
 
String *
51
 
Hybrid_type_traits::val_str(Hybrid_type *val, String *to, uint8_t decimals) const
52
 
{
53
 
  to->set_real(val->real, decimals, &my_charset_bin);
54
 
  return to;
55
 
}
56
 
 
57
 
/* Hybrid_type_traits_decimal */
58
 
static const Hybrid_type_traits_decimal decimal_traits_instance;
59
 
 
60
 
const Hybrid_type_traits_decimal *Hybrid_type_traits_decimal::instance()
61
 
{
62
 
  return &decimal_traits_instance;
63
 
}
64
 
 
65
 
 
66
 
void
67
 
Hybrid_type_traits_decimal::fix_length_and_dec(Item *item, Item *arg) const
68
 
{
69
 
  item->decimals= arg->decimals;
70
 
  item->max_length= min(arg->max_length + DECIMAL_LONGLONG_DIGITS,
71
 
                        (unsigned int)DECIMAL_MAX_STR_LENGTH);
72
 
}
73
 
 
74
 
 
75
 
void Hybrid_type_traits_decimal::set_zero(Hybrid_type *val) const
76
 
{
77
 
  my_decimal_set_zero(&val->dec_buf[0]);
78
 
  val->used_dec_buf_no= 0;
79
 
}
80
 
 
81
 
 
82
 
void Hybrid_type_traits_decimal::add(Hybrid_type *val, Field *f) const
83
 
{
84
 
  my_decimal_add(E_DEC_FATAL_ERROR,
85
 
                 &val->dec_buf[val->used_dec_buf_no ^ 1],
86
 
                 &val->dec_buf[val->used_dec_buf_no],
87
 
                 f->val_decimal(&val->dec_buf[2]));
88
 
  val->used_dec_buf_no^= 1;
89
 
}
90
 
 
91
 
 
92
 
/**
93
 
  @todo
94
 
  what is '4' for scale?
95
 
*/
96
 
void Hybrid_type_traits_decimal::div(Hybrid_type *val, uint64_t u) const
97
 
{
98
 
  int2my_decimal(E_DEC_FATAL_ERROR, u, true, &val->dec_buf[2]);
99
 
  /* XXX: what is '4' for scale? */
100
 
  my_decimal_div(E_DEC_FATAL_ERROR,
101
 
                 &val->dec_buf[val->used_dec_buf_no ^ 1],
102
 
                 &val->dec_buf[val->used_dec_buf_no],
103
 
                 &val->dec_buf[2], 4);
104
 
  val->used_dec_buf_no^= 1;
105
 
}
106
 
 
107
 
 
108
 
int64_t
109
 
Hybrid_type_traits_decimal::val_int(Hybrid_type *val, bool unsigned_flag) const
110
 
{
111
 
  int64_t result;
112
 
  my_decimal2int(E_DEC_FATAL_ERROR, &val->dec_buf[val->used_dec_buf_no],
113
 
                 unsigned_flag, &result);
114
 
  return result;
115
 
}
116
 
 
117
 
 
118
 
double
119
 
Hybrid_type_traits_decimal::val_real(Hybrid_type *val) const
120
 
{
121
 
  my_decimal2double(E_DEC_FATAL_ERROR, &val->dec_buf[val->used_dec_buf_no],
122
 
                    &val->real);
123
 
  return val->real;
124
 
}
125
 
 
126
 
 
127
 
String *
128
 
Hybrid_type_traits_decimal::val_str(Hybrid_type *val, String *to,
129
 
                                    uint8_t decimals) const
130
 
{
131
 
  my_decimal_round(E_DEC_FATAL_ERROR, &val->dec_buf[val->used_dec_buf_no],
132
 
                   decimals, false, &val->dec_buf[2]);
133
 
  my_decimal2string(E_DEC_FATAL_ERROR, &val->dec_buf[2], 0, 0, 0, to);
134
 
  return to;
135
 
}
136
 
 
137
 
/* Hybrid_type_traits_integer */
138
 
static const Hybrid_type_traits_integer integer_traits_instance;
139
 
 
140
 
const Hybrid_type_traits_integer *Hybrid_type_traits_integer::instance()
141
 
{
142
 
  return &integer_traits_instance;
143
 
}
144
 
 
145
 
void
146
 
Hybrid_type_traits_integer::fix_length_and_dec(Item *item,
147
 
                                               Item *arg __attribute__((unused))) const
148
 
{
149
 
  item->decimals= 0;
150
 
  item->max_length= MY_INT64_NUM_DECIMAL_DIGITS;
151
 
  item->unsigned_flag= 0;
152
 
}
153
 
 
154
 
/*****************************************************************************
155
 
** Item functions
156
 
*****************************************************************************/
157
 
 
158
 
/**
159
 
  Init all special items.
160
 
*/
161
 
 
162
 
void item_init(void)
163
 
{
164
 
}
165
 
 
166
 
 
167
 
/**
168
 
  @todo
169
 
    Make this functions class dependent
170
 
*/
171
 
 
 
58
bool Item::is_expensive_processor(unsigned char *)
 
59
{
 
60
  return false;
 
61
}
 
62
 
 
63
void Item::fix_after_pullout(Select_Lex *, Item **)
 
64
{}
 
65
 
 
66
Field *Item::tmp_table_field(Table *)
 
67
{
 
68
  return NULL;
 
69
}
 
70
 
 
71
const char *Item::full_name(void) const
 
72
{
 
73
  return name ? name : "???";
 
74
}
 
75
 
 
76
int64_t Item::val_int_endpoint(bool, bool *)
 
77
{
 
78
  assert(0);
 
79
  return 0;
 
80
}
 
81
 
 
82
/** @todo Make this functions class dependent */
172
83
bool Item::val_bool()
173
84
{
174
 
  switch(result_type()) {
175
 
  case INT_RESULT:
176
 
    return val_int() != 0;
177
 
  case DECIMAL_RESULT:
 
85
  switch(result_type()) 
178
86
  {
179
 
    my_decimal decimal_value;
180
 
    my_decimal *val= val_decimal(&decimal_value);
181
 
    if (val)
182
 
      return !my_decimal_is_zero(val);
183
 
    return 0;
184
 
  }
185
 
  case REAL_RESULT:
186
 
  case STRING_RESULT:
187
 
    return val_real() != 0.0;
188
 
  case ROW_RESULT:
189
 
  default:
190
 
    assert(0);
191
 
    return 0;                                   // Wrong (but safe)
 
87
    case INT_RESULT:
 
88
      return val_int() != 0;
 
89
    case DECIMAL_RESULT:
 
90
    {
 
91
      my_decimal decimal_value;
 
92
      my_decimal *val= val_decimal(&decimal_value);
 
93
      if (val)
 
94
        return !my_decimal_is_zero(val);
 
95
      return false;
 
96
    }
 
97
    case REAL_RESULT:
 
98
    case STRING_RESULT:
 
99
      return val_real() != 0.0;
 
100
    case ROW_RESULT:
 
101
    default:
 
102
      assert(0);
 
103
      return false;
192
104
  }
193
105
}
194
106
 
195
 
 
196
107
String *Item::val_string_from_real(String *str)
197
108
{
198
109
  double nr= val_real();
199
110
  if (null_value)
200
 
    return 0;                                   /* purecov: inspected */
201
 
  str->set_real(nr,decimals, &my_charset_bin);
 
111
    return NULL;
 
112
 
 
113
  str->set_real(nr, decimals, &my_charset_bin);
202
114
  return str;
203
115
}
204
116
 
205
 
 
206
117
String *Item::val_string_from_int(String *str)
207
118
{
208
119
  int64_t nr= val_int();
209
120
  if (null_value)
210
 
    return 0;
 
121
    return NULL;
 
122
 
211
123
  str->set_int(nr, unsigned_flag, &my_charset_bin);
212
124
  return str;
213
125
}
214
126
 
215
 
 
216
127
String *Item::val_string_from_decimal(String *str)
217
128
{
218
129
  my_decimal dec_buf, *dec= val_decimal(&dec_buf);
219
130
  if (null_value)
220
 
    return 0;
 
131
    return NULL;
 
132
 
221
133
  my_decimal_round(E_DEC_FATAL_ERROR, dec, decimals, false, &dec_buf);
222
134
  my_decimal2string(E_DEC_FATAL_ERROR, &dec_buf, 0, 0, 0, str);
223
135
  return str;
224
136
}
225
137
 
226
 
 
227
138
my_decimal *Item::val_decimal_from_real(my_decimal *decimal_value)
228
139
{
229
140
  double nr= val_real();
230
141
  if (null_value)
231
 
    return 0;
 
142
    return NULL;
 
143
 
232
144
  double2my_decimal(E_DEC_FATAL_ERROR, nr, decimal_value);
233
145
  return (decimal_value);
234
146
}
235
147
 
236
 
 
237
148
my_decimal *Item::val_decimal_from_int(my_decimal *decimal_value)
238
149
{
239
150
  int64_t nr= val_int();
240
151
  if (null_value)
241
 
    return 0;
 
152
    return NULL;
 
153
 
242
154
  int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value);
243
155
  return decimal_value;
244
156
}
245
157
 
246
 
 
247
158
my_decimal *Item::val_decimal_from_string(my_decimal *decimal_value)
248
159
{
249
160
  String *res;
250
161
  char *end_ptr;
251
162
  if (!(res= val_str(&str_value)))
252
 
    return 0;                                   // NULL or EOM
 
163
    return NULL;
253
164
 
254
165
  end_ptr= (char*) res->ptr()+ res->length();
255
166
  if (str2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_BAD_NUM,
256
 
                     res->ptr(), res->length(), res->charset(),
 
167
                     res->ptr(), 
 
168
                     res->length(), 
 
169
                     res->charset(),
257
170
                     decimal_value) & E_DEC_BAD_NUM)
258
171
  {
259
 
    push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
172
    push_warning_printf(current_session, 
 
173
                        DRIZZLE_ERROR::WARN_LEVEL_WARN,
260
174
                        ER_TRUNCATED_WRONG_VALUE,
261
175
                        ER(ER_TRUNCATED_WRONG_VALUE), "DECIMAL",
262
176
                        str_value.c_ptr());
264
178
  return decimal_value;
265
179
}
266
180
 
267
 
 
268
181
my_decimal *Item::val_decimal_from_date(my_decimal *decimal_value)
269
182
{
270
 
  assert(fixed == 1);
 
183
  assert(fixed);
271
184
  DRIZZLE_TIME ltime;
272
185
  if (get_date(&ltime, TIME_FUZZY_DATE))
273
186
  {
274
187
    my_decimal_set_zero(decimal_value);
275
188
    null_value= 1;                               // set NULL, stop processing
276
 
    return 0;
 
189
    return NULL;
277
190
  }
278
191
  return date2my_decimal(&ltime, decimal_value);
279
192
}
280
193
 
281
 
 
282
194
my_decimal *Item::val_decimal_from_time(my_decimal *decimal_value)
283
195
{
284
 
  assert(fixed == 1);
 
196
  assert(fixed);
285
197
  DRIZZLE_TIME ltime;
286
198
  if (get_time(&ltime))
287
199
  {
288
200
    my_decimal_set_zero(decimal_value);
289
 
    return 0;
 
201
    return NULL;
290
202
  }
291
203
  return date2my_decimal(&ltime, decimal_value);
292
204
}
293
205
 
294
 
 
295
206
double Item::val_real_from_decimal()
296
207
{
297
208
  /* Note that fix_fields may not be called for Item_avg_field items */
303
214
  return result;
304
215
}
305
216
 
306
 
 
307
217
int64_t Item::val_int_from_decimal()
308
218
{
309
219
  /* Note that fix_fields may not be called for Item_avg_field items */
324
234
  return field->store_time(&ltime, DRIZZLE_TIMESTAMP_TIME);
325
235
}
326
236
 
327
 
 
328
237
int Item::save_date_in_field(Field *field)
329
238
{
330
239
  DRIZZLE_TIME ltime;
334
243
  return field->store_time(&ltime, DRIZZLE_TIMESTAMP_DATETIME);
335
244
}
336
245
 
337
 
 
338
 
/*
339
 
  Store the string value in field directly
340
 
 
341
 
  SYNOPSIS
342
 
    Item::save_str_value_in_field()
343
 
    field   a pointer to field where to store
344
 
    result  the pointer to the string value to be stored
345
 
 
346
 
  DESCRIPTION
347
 
    The method is used by Item_*::save_in_field implementations
348
 
    when we don't need to calculate the value to store
349
 
    See Item_string::save_in_field() implementation for example
350
 
 
351
 
  IMPLEMENTATION
352
 
    Check if the Item is null and stores the NULL or the
353
 
    result value in the field accordingly.
354
 
 
355
 
  RETURN
356
 
    Nonzero value if error
357
 
*/
358
 
 
 
246
/**
 
247
 * Check if the Item is null and stores the NULL or the
 
248
 * result value in the field accordingly.
 
249
 */
359
250
int Item::save_str_value_in_field(Field *field, String *result)
360
251
{
361
252
  if (null_value)
362
253
    return set_field_to_null(field);
363
254
  field->set_notnull();
364
 
  return field->store(result->ptr(), result->length(),
365
 
                      collation.collation);
 
255
  return field->store(result->ptr(), result->length(), collation.collation);
366
256
}
367
257
 
368
 
 
369
258
Item::Item():
370
 
  is_expensive_cache(-1), rsize(0), name(0), orig_name(0), name_length(0),
371
 
  fixed(0), is_autogenerated_name(true),
 
259
  is_expensive_cache(-1),
 
260
  name(0), 
 
261
  name_length(0),
 
262
  orig_name(0), 
 
263
  max_length(0), 
 
264
  marker(0),
 
265
  decimals(0),
 
266
  fixed(false),
 
267
  maybe_null(false),
 
268
  null_value(false),
 
269
  unsigned_flag(false), 
 
270
  with_sum_func(false),
 
271
  is_autogenerated_name(true),
 
272
  with_subselect(false),
372
273
  collation(&my_charset_bin, DERIVATION_COERCIBLE)
373
274
{
374
 
  marker= 0;
375
 
  maybe_null= false;
376
 
  null_value= false;
377
 
  with_sum_func= false;
378
 
  unsigned_flag= false;
379
 
  decimals= 0; 
380
 
  max_length= 0;
381
 
  with_subselect= 0;
382
275
  cmp_context= (Item_result)-1;
383
276
 
384
277
  /* Put item in free list so that we can free all items at end */
385
 
  THD *thd= current_thd;
386
 
  next= thd->free_list;
387
 
  thd->free_list= this;
 
278
  Session *session= current_session;
 
279
  next= session->free_list;
 
280
  session->free_list= this;
 
281
 
388
282
  /*
389
283
    Item constructor can be called during execution other then SQL_COM
390
 
    command => we should check thd->lex->current_select on zero (thd->lex
 
284
    command => we should check session->lex->current_select on zero (session->lex
391
285
    can be uninitialised)
392
286
  */
393
 
  if (thd->lex->current_select)
 
287
  if (session->lex->current_select)
394
288
  {
395
 
    enum_parsing_place place= 
396
 
      thd->lex->current_select->parsing_place;
397
 
    if (place == SELECT_LIST ||
398
 
        place == IN_HAVING)
399
 
      thd->lex->current_select->select_n_having_items++;
 
289
    enum_parsing_place place= session->lex->current_select->parsing_place;
 
290
    if (place == SELECT_LIST || place == IN_HAVING)
 
291
      session->lex->current_select->select_n_having_items++;
400
292
  }
401
293
}
402
294
 
403
 
/**
404
 
  Constructor used by Item_field, Item_ref & aggregate (sum)
405
 
  functions.
406
 
 
407
 
  Used for duplicating lists in processing queries with temporary
408
 
  tables.
409
 
*/
410
 
Item::Item(THD *thd, Item *item):
 
295
Item::Item(Session *session, Item *item):
411
296
  is_expensive_cache(-1),
412
 
  rsize(0),
413
297
  str_value(item->str_value),
414
298
  name(item->name),
 
299
  name_length(item->name_length),
415
300
  orig_name(item->orig_name),
416
301
  max_length(item->max_length),
417
302
  marker(item->marker),
418
303
  decimals(item->decimals),
 
304
  fixed(item->fixed),
419
305
  maybe_null(item->maybe_null),
420
306
  null_value(item->null_value),
421
307
  unsigned_flag(item->unsigned_flag),
422
308
  with_sum_func(item->with_sum_func),
423
 
  fixed(item->fixed),
 
309
  is_autogenerated_name(item->is_autogenerated_name),
 
310
  with_subselect(item->with_subselect),
424
311
  collation(item->collation),
425
312
  cmp_context(item->cmp_context)
426
313
{
427
 
  next= thd->free_list;                         // Put in free list
428
 
  thd->free_list= this;
 
314
  /* Put this item in the session's free list */
 
315
  next= session->free_list;
 
316
  session->free_list= this;
429
317
}
430
318
 
431
 
 
432
 
uint Item::decimal_precision() const
 
319
uint32_t Item::decimal_precision() const
433
320
{
434
321
  Item_result restype= result_type();
435
322
 
436
323
  if ((restype == DECIMAL_RESULT) || (restype == INT_RESULT))
437
324
    return min(my_decimal_length_to_precision(max_length, decimals, unsigned_flag),
438
 
               (unsigned int)DECIMAL_MAX_PRECISION);
439
 
  return min(max_length, (uint32_t)DECIMAL_MAX_PRECISION);
440
 
}
441
 
 
 
325
               (uint32_t) DECIMAL_MAX_PRECISION);
 
326
  return min(max_length, (uint32_t) DECIMAL_MAX_PRECISION);
 
327
}
 
328
 
 
329
int Item::decimal_int_part() const
 
330
{
 
331
  return my_decimal_int_part(decimal_precision(), decimals);
 
332
}
 
333
 
 
334
void Item::print(String *str, enum_query_type)
 
335
{
 
336
  str->append(full_name());
 
337
}
442
338
 
443
339
void Item::print_item_w_name(String *str, enum_query_type query_type)
444
340
{
446
342
 
447
343
  if (name)
448
344
  {
449
 
    THD *thd= current_thd;
450
345
    str->append(STRING_WITH_LEN(" AS "));
451
 
    append_identifier(thd, str, name, (uint) strlen(name));
 
346
    str->append_identifier(name, (uint32_t) strlen(name));
452
347
  }
453
348
}
454
349
 
 
350
void Item::split_sum_func(Session *, Item **, List<Item> &)
 
351
{}
455
352
 
456
353
void Item::cleanup()
457
354
{
458
 
  fixed=0;
 
355
  fixed= false;
459
356
  marker= 0;
460
357
  if (orig_name)
461
358
    name= orig_name;
462
359
  return;
463
360
}
464
361
 
465
 
 
466
 
/**
467
 
  cleanup() item if it is 'fixed'.
468
 
 
469
 
  @param arg   a dummy parameter, is not used here
470
 
*/
471
 
 
472
 
bool Item::cleanup_processor(uchar *arg __attribute__((unused)))
473
 
{
474
 
  if (fixed)
475
 
    cleanup();
476
 
  return false;
477
 
}
478
 
 
479
 
 
480
 
/**
481
 
  rename item (used for views, cleanup() return original name).
482
 
 
483
 
  @param new_name       new name of item;
484
 
*/
485
 
 
486
362
void Item::rename(char *new_name)
487
363
{
488
364
  /*
489
365
    we can compare pointers to names here, because if name was not changed,
490
366
    pointer will be same
491
367
  */
492
 
  if (!orig_name && new_name != name)
 
368
  if (! orig_name && new_name != name)
493
369
    orig_name= name;
494
370
  name= new_name;
495
371
}
496
372
 
497
 
 
498
 
/**
499
 
  Traverse item tree possibly transforming it (replacing items).
500
 
 
501
 
  This function is designed to ease transformation of Item trees.
502
 
  Re-execution note: every such transformation is registered for
503
 
  rollback by THD::change_item_tree() and is rolled back at the end
504
 
  of execution by THD::rollback_item_tree_changes().
505
 
 
506
 
  Therefore:
507
 
  - this function can not be used at prepared statement prepare
508
 
  (in particular, in fix_fields!), as only permanent
509
 
  transformation of Item trees are allowed at prepare.
510
 
  - the transformer function shall allocate new Items in execution
511
 
  memory root (thd->mem_root) and not anywhere else: allocated
512
 
  items will be gone in the end of execution.
513
 
 
514
 
  If you don't need to transform an item tree, but only traverse
515
 
  it, please use Item::walk() instead.
516
 
 
517
 
 
518
 
  @param transformer    functor that performs transformation of a subtree
519
 
  @param arg            opaque argument passed to the functor
520
 
 
521
 
  @return
522
 
    Returns pointer to the new subtree root.  THD::change_item_tree()
523
 
    should be called for it if transformation took place, i.e. if a
524
 
    pointer to newly allocated item is returned.
525
 
*/
526
 
 
527
 
Item* Item::transform(Item_transformer transformer, uchar *arg)
 
373
Item* Item::transform(Item_transformer transformer, unsigned char *arg)
528
374
{
529
375
  return (this->*transformer)(arg);
530
376
}
531
377
 
532
 
 
533
 
Item_ident::Item_ident(Name_resolution_context *context_arg,
534
 
                       const char *db_name_arg,const char *table_name_arg,
535
 
                       const char *field_name_arg)
536
 
  :orig_db_name(db_name_arg), orig_table_name(table_name_arg),
537
 
   orig_field_name(field_name_arg), context(context_arg),
538
 
   db_name(db_name_arg), table_name(table_name_arg),
539
 
   field_name(field_name_arg),
540
 
   alias_name_used(false), cached_field_index(NO_CACHED_FIELD_INDEX),
541
 
   cached_table(0), depended_from(0)
542
 
{
543
 
  name = (char*) field_name_arg;
544
 
}
545
 
 
546
 
 
547
 
/**
548
 
  Constructor used by Item_field & Item_*_ref (see Item comment)
549
 
*/
550
 
 
551
 
Item_ident::Item_ident(THD *thd, Item_ident *item)
552
 
  :Item(thd, item),
553
 
   orig_db_name(item->orig_db_name),
554
 
   orig_table_name(item->orig_table_name), 
555
 
   orig_field_name(item->orig_field_name),
556
 
   context(item->context),
557
 
   db_name(item->db_name),
558
 
   table_name(item->table_name),
559
 
   field_name(item->field_name),
560
 
   alias_name_used(item->alias_name_used),
561
 
   cached_field_index(item->cached_field_index),
562
 
   cached_table(item->cached_table),
563
 
   depended_from(item->depended_from)
564
 
{}
565
 
 
566
 
void Item_ident::cleanup()
567
 
{
568
 
#ifdef CANT_BE_USED_AS_MEMORY_IS_FREED
569
 
                       db_name ? db_name : "(null)",
570
 
                       orig_db_name ? orig_db_name : "(null)",
571
 
                       table_name ? table_name : "(null)",
572
 
                       orig_table_name ? orig_table_name : "(null)",
573
 
                       field_name ? field_name : "(null)",
574
 
                       orig_field_name ? orig_field_name : "(null)"));
575
 
#endif
576
 
  Item::cleanup();
577
 
  db_name= orig_db_name; 
578
 
  table_name= orig_table_name;
579
 
  field_name= orig_field_name;
580
 
  depended_from= 0;
581
 
  return;
582
 
}
583
 
 
584
 
bool Item_ident::remove_dependence_processor(uchar * arg)
585
 
{
586
 
  if (depended_from == (st_select_lex *) arg)
587
 
    depended_from= 0;
588
 
  return(0);
589
 
}
590
 
 
591
 
 
592
 
/**
593
 
  Store the pointer to this item field into a list if not already there.
594
 
 
595
 
  The method is used by Item::walk to collect all unique Item_field objects
596
 
  from a tree of Items into a set of items represented as a list.
597
 
 
598
 
  Item_cond::walk() and Item_func::walk() stop the evaluation of the
599
 
  processor function for its arguments once the processor returns
600
 
  true.Therefore in order to force this method being called for all item
601
 
  arguments in a condition the method must return false.
602
 
 
603
 
  @param arg  pointer to a List<Item_field>
604
 
 
605
 
  @return
606
 
    false to force the evaluation of collect_item_field_processor
607
 
    for the subsequent items.
608
 
*/
609
 
 
610
 
bool Item_field::collect_item_field_processor(uchar *arg)
611
 
{
612
 
  List<Item_field> *item_list= (List<Item_field>*) arg;
613
 
  List_iterator<Item_field> item_list_it(*item_list);
614
 
  Item_field *curr_item;
615
 
  while ((curr_item= item_list_it++))
616
 
  {
617
 
    if (curr_item->eq(this, 1))
618
 
      return(false); /* Already in the set. */
619
 
  }
620
 
  item_list->push_back(this);
621
 
  return(false);
622
 
}
623
 
 
624
 
 
625
 
/**
626
 
  Check if an Item_field references some field from a list of fields.
627
 
 
628
 
  Check whether the Item_field represented by 'this' references any
629
 
  of the fields in the keyparts passed via 'arg'. Used with the
630
 
  method Item::walk() to test whether any keypart in a sequence of
631
 
  keyparts is referenced in an expression.
632
 
 
633
 
  @param arg   Field being compared, arg must be of type Field
634
 
 
635
 
  @retval
636
 
    true  if 'this' references the field 'arg'
637
 
  @retval
638
 
    false otherwise
639
 
*/
640
 
 
641
 
bool Item_field::find_item_in_field_list_processor(uchar *arg)
642
 
{
643
 
  KEY_PART_INFO *first_non_group_part= *((KEY_PART_INFO **) arg);
644
 
  KEY_PART_INFO *last_part= *(((KEY_PART_INFO **) arg) + 1);
645
 
  KEY_PART_INFO *cur_part;
646
 
 
647
 
  for (cur_part= first_non_group_part; cur_part != last_part; cur_part++)
648
 
  {
649
 
    if (field->eq(cur_part->field))
650
 
      return true;
651
 
  }
652
 
  return false;
653
 
}
654
 
 
655
 
 
656
 
/*
657
 
  Mark field in read_map
658
 
 
659
 
  NOTES
660
 
    This is used by filesort to register used fields in a a temporary
661
 
    column read set or to register used fields in a view
662
 
*/
663
 
 
664
 
bool Item_field::register_field_in_read_map(uchar *arg)
665
 
{
666
 
  TABLE *table= (TABLE *) arg;
667
 
  if (field->table == table || !table)
668
 
    bitmap_set_bit(field->table->read_set, field->field_index);
669
 
  return 0;
670
 
}
671
 
 
672
 
 
673
 
bool Item::check_cols(uint c)
 
378
bool Item::check_cols(uint32_t c)
674
379
{
675
380
  if (c != 1)
676
381
  {
677
382
    my_error(ER_OPERAND_COLUMNS, MYF(0), c);
678
 
    return 1;
 
383
    return true;
679
384
  }
680
 
  return 0;
 
385
  return false;
681
386
}
682
387
 
683
 
 
684
 
void Item::set_name(const char *str, uint length, const CHARSET_INFO * const cs)
 
388
void Item::set_name(const char *str, uint32_t length, const CHARSET_INFO * const cs)
685
389
{
686
390
  if (!length)
687
391
  {
692
396
  }
693
397
  if (cs->ctype)
694
398
  {
695
 
    uint orig_len= length;
696
 
    /*
697
 
      This will probably need a better implementation in the future:
698
 
      a function in CHARSET_INFO structure.
699
 
    */
700
 
    while (length && !my_isgraph(cs,*str))
701
 
    {                                           // Fix problem with yacc
 
399
    uint32_t orig_len= length;
 
400
    while (length && ! my_isgraph(cs, *str))
 
401
    {
 
402
      /* Fix problem with yacc */
702
403
      length--;
703
404
      str++;
704
405
    }
705
 
    if (orig_len != length && !is_autogenerated_name)
 
406
    if (orig_len != length && ! is_autogenerated_name)
706
407
    {
707
408
      if (length == 0)
708
 
        push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
709
 
                            ER_NAME_BECOMES_EMPTY, ER(ER_NAME_BECOMES_EMPTY),
 
409
        push_warning_printf(current_session, 
 
410
                            DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
411
                            ER_NAME_BECOMES_EMPTY, 
 
412
                            ER(ER_NAME_BECOMES_EMPTY),
710
413
                            str + length - orig_len);
711
414
      else
712
 
        push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
713
 
                            ER_REMOVED_SPACES, ER(ER_REMOVED_SPACES),
 
415
        push_warning_printf(current_session, 
 
416
                            DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
417
                            ER_REMOVED_SPACES, 
 
418
                            ER(ER_REMOVED_SPACES),
714
419
                            str + length - orig_len);
715
420
    }
716
421
  }
717
 
  if (!my_charset_same(cs, system_charset_info))
718
 
  {
719
 
    size_t res_length;
720
 
    name= sql_strmake_with_convert(str, name_length= length, cs,
721
 
                                   MAX_ALIAS_NAME, system_charset_info,
722
 
                                   &res_length);
723
 
  }
724
 
  else
725
 
    name= sql_strmake(str, (name_length= min(length,(unsigned int)MAX_ALIAS_NAME)));
 
422
  name= sql_strmake(str, length);
726
423
}
727
424
 
728
 
 
729
 
/**
730
 
  @details
731
 
  This function is called when:
732
 
  - Comparing items in the WHERE clause (when doing where optimization)
733
 
  - When trying to find an ORDER BY/GROUP BY item in the SELECT part
734
 
*/
735
 
 
736
 
bool Item::eq(const Item *item, bool binary_cmp __attribute__((unused))) const
 
425
bool Item::eq(const Item *item, bool) const
737
426
{
738
427
  /*
739
428
    Note, that this is never true if item is a Item_param:
740
429
    for all basic constants we have special checks, and Item_param's
741
430
    type() can be only among basic constant types.
742
431
  */
743
 
  return type() == item->type() && name && item->name &&
744
 
    !my_strcasecmp(system_charset_info,name,item->name);
 
432
  return type() == item->type() && 
 
433
         name && 
 
434
         item->name &&
 
435
         ! my_strcasecmp(system_charset_info, name, item->name);
745
436
}
746
437
 
747
 
 
748
438
Item *Item::safe_charset_converter(const CHARSET_INFO * const tocs)
749
439
{
750
440
  Item_func_conv_charset *conv= new Item_func_conv_charset(this, tocs, 1);
751
441
  return conv->safe ? conv : NULL;
752
442
}
753
443
 
754
 
 
755
 
/**
756
 
  @details
757
 
  Created mostly for mysql_prepare_table(). Important
758
 
  when a string ENUM/SET column is described with a numeric default value:
759
 
 
760
 
  CREATE TABLE t1(a SET('a') DEFAULT 1);
761
 
 
762
 
  We cannot use generic Item::safe_charset_converter(), because
763
 
  the latter returns a non-fixed Item, so val_str() crashes afterwards.
764
 
  Override Item_num method, to return a fixed item.
765
 
*/
766
 
Item *Item_num::safe_charset_converter(const CHARSET_INFO * const tocs __attribute__((unused)))
767
 
{
768
 
  Item_string *conv;
769
 
  char buf[64];
770
 
  String *s, tmp(buf, sizeof(buf), &my_charset_bin);
771
 
  s= val_str(&tmp);
772
 
  if ((conv= new Item_string(s->ptr(), s->length(), s->charset())))
773
 
  {
774
 
    conv->str_value.copy();
775
 
    conv->str_value.mark_as_const();
776
 
  }
777
 
  return conv;
778
 
}
779
 
 
780
 
 
781
 
Item *Item_static_float_func::safe_charset_converter(const CHARSET_INFO * const tocs __attribute__((unused)))
782
 
{
783
 
  Item_string *conv;
784
 
  char buf[64];
785
 
  String *s, tmp(buf, sizeof(buf), &my_charset_bin);
786
 
  s= val_str(&tmp);
787
 
  if ((conv= new Item_static_string_func(func_name, s->ptr(), s->length(),
788
 
                                         s->charset())))
789
 
  {
790
 
    conv->str_value.copy();
791
 
    conv->str_value.mark_as_const();
792
 
  }
793
 
  return conv;
794
 
}
795
 
 
796
 
 
797
 
Item *Item_string::safe_charset_converter(const CHARSET_INFO * const tocs)
798
 
{
799
 
  Item_string *conv;
800
 
  uint conv_errors;
801
 
  char *ptr;
802
 
  String tmp, cstr, *ostr= val_str(&tmp);
803
 
  cstr.copy(ostr->ptr(), ostr->length(), ostr->charset(), tocs, &conv_errors);
804
 
  if (conv_errors || !(conv= new Item_string(cstr.ptr(), cstr.length(),
805
 
                                             cstr.charset(),
806
 
                                             collation.derivation)))
807
 
  {
808
 
    /*
809
 
      Safe conversion is not possible (or EOM).
810
 
      We could not convert a string into the requested character set
811
 
      without data loss. The target charset does not cover all the
812
 
      characters from the string. Operation cannot be done correctly.
813
 
    */
814
 
    return NULL;
815
 
  }
816
 
  if (!(ptr= current_thd->strmake(cstr.ptr(), cstr.length())))
817
 
    return NULL;
818
 
  conv->str_value.set(ptr, cstr.length(), cstr.charset());
819
 
  /* Ensure that no one is going to change the result string */
820
 
  conv->str_value.mark_as_const();
821
 
  return conv;
822
 
}
823
 
 
824
 
 
825
 
Item *Item_param::safe_charset_converter(const CHARSET_INFO * const tocs)
826
 
{
827
 
  if (const_item())
828
 
  {
829
 
    uint cnv_errors;
830
 
    String *ostr= val_str(&cnvstr);
831
 
    cnvitem->str_value.copy(ostr->ptr(), ostr->length(),
832
 
                            ostr->charset(), tocs, &cnv_errors);
833
 
    if (cnv_errors)
834
 
       return NULL;
835
 
    cnvitem->str_value.mark_as_const();
836
 
    cnvitem->max_length= cnvitem->str_value.numchars() * tocs->mbmaxlen;
837
 
    return cnvitem;
838
 
  }
839
 
  return NULL;
840
 
}
841
 
 
842
 
 
843
 
Item *Item_static_string_func::safe_charset_converter(const CHARSET_INFO * const tocs)
844
 
{
845
 
  Item_string *conv;
846
 
  uint conv_errors;
847
 
  String tmp, cstr, *ostr= val_str(&tmp);
848
 
  cstr.copy(ostr->ptr(), ostr->length(), ostr->charset(), tocs, &conv_errors);
849
 
  if (conv_errors ||
850
 
      !(conv= new Item_static_string_func(func_name,
851
 
                                          cstr.ptr(), cstr.length(),
852
 
                                          cstr.charset(),
853
 
                                          collation.derivation)))
854
 
  {
855
 
    /*
856
 
      Safe conversion is not possible (or EOM).
857
 
      We could not convert a string into the requested character set
858
 
      without data loss. The target charset does not cover all the
859
 
      characters from the string. Operation cannot be done correctly.
860
 
    */
861
 
    return NULL;
862
 
  }
863
 
  conv->str_value.copy();
864
 
  /* Ensure that no one is going to change the result string */
865
 
  conv->str_value.mark_as_const();
866
 
  return conv;
867
 
}
868
 
 
869
 
 
870
 
bool Item_string::eq(const Item *item, bool binary_cmp) const
871
 
{
872
 
  if (type() == item->type() && item->basic_const_item())
873
 
  {
874
 
    if (binary_cmp)
875
 
      return !stringcmp(&str_value, &item->str_value);
876
 
    return (collation.collation == item->collation.collation &&
877
 
            !sortcmp(&str_value, &item->str_value, collation.collation));
878
 
  }
879
 
  return 0;
880
 
}
881
 
 
882
 
 
883
 
/**
884
 
  Get the value of the function as a DRIZZLE_TIME structure.
885
 
  As a extra convenience the time structure is reset on error!
886
 
*/
887
 
 
888
 
bool Item::get_date(DRIZZLE_TIME *ltime,uint fuzzydate)
 
444
bool Item::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
889
445
{
890
446
  if (result_type() == STRING_RESULT)
891
447
  {
900
456
  {
901
457
    int64_t value= val_int();
902
458
    int was_cut;
903
 
    if (number_to_datetime(value, ltime, fuzzydate, &was_cut) == -1LL)
 
459
    if (number_to_datetime(value, ltime, fuzzydate, &was_cut) == -1L)
904
460
    {
905
461
      char buff[22], *end;
906
462
      end= int64_t10_to_str(value, buff, -10);
907
 
      make_truncated_value_warning(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
463
      make_truncated_value_warning(current_session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
908
464
                                   buff, (int) (end-buff), DRIZZLE_TIMESTAMP_NONE,
909
 
                                   NullS);
 
465
                                   NULL);
910
466
      goto err;
911
467
    }
912
468
  }
913
 
  return 0;
 
469
  return false;
914
470
 
915
471
err:
916
472
  memset(ltime, 0, sizeof(*ltime));
917
 
  return 1;
 
473
  return true;
918
474
}
919
475
 
920
 
/**
921
 
  Get time of first argument.\
922
 
 
923
 
  As a extra convenience the time structure is reset on error!
924
 
*/
925
 
 
926
476
bool Item::get_time(DRIZZLE_TIME *ltime)
927
477
{
928
478
  char buff[40];
931
481
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
932
482
  {
933
483
    memset(ltime, 0, sizeof(*ltime));
934
 
    return 1;
 
484
    return true;
935
485
  }
936
 
  return 0;
 
486
  return false;
 
487
}
 
488
 
 
489
bool Item::get_date_result(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
 
490
{
 
491
  return get_date(ltime,fuzzydate);
 
492
}
 
493
 
 
494
bool Item::is_null()
 
495
{
 
496
  return false;
 
497
}
 
498
 
 
499
void Item::update_null_value ()
 
500
{
 
501
  (void) val_int();
 
502
}
 
503
 
 
504
void Item::top_level_item(void)
 
505
{}
 
506
 
 
507
void Item::set_result_field(Field *)
 
508
{}
 
509
 
 
510
bool Item::is_result_field(void)
 
511
{
 
512
  return false;
 
513
}
 
514
 
 
515
bool Item::is_bool_func(void)
 
516
{
 
517
  return false;
 
518
}
 
519
 
 
520
void Item::save_in_result_field(bool)
 
521
{}
 
522
 
 
523
void Item::no_rows_in_result(void)
 
524
{}
 
525
 
 
526
Item *Item::copy_or_same(Session *)
 
527
{
 
528
  return this;
 
529
}
 
530
 
 
531
Item *Item::copy_andor_structure(Session *)
 
532
{
 
533
  return this;
 
534
}
 
535
 
 
536
Item *Item::real_item(void)
 
537
{
 
538
  return this;
 
539
}
 
540
 
 
541
const Item *Item::real_item(void) const
 
542
{
 
543
  return this;
 
544
}
 
545
 
 
546
Item *Item::get_tmp_table_item(Session *session)
 
547
{
 
548
  return copy_or_same(session);
937
549
}
938
550
 
939
551
const CHARSET_INFO *Item::default_charset()
940
552
{
941
 
  return current_thd->variables.collation_connection;
942
 
}
943
 
 
944
 
 
945
 
/*
946
 
  Save value in field, but don't give any warnings
947
 
 
948
 
  NOTES
949
 
   This is used to temporary store and retrieve a value in a column,
950
 
   for example in opt_range to adjust the key value to fit the column.
951
 
*/
 
553
  return current_session->variables.getCollation();
 
554
}
 
555
 
 
556
const CHARSET_INFO *Item::compare_collation()
 
557
{
 
558
  return NULL;
 
559
}
 
560
 
 
561
bool Item::walk(Item_processor processor, bool, unsigned char *arg)
 
562
{
 
563
  return (this->*processor)(arg);
 
564
}
 
565
 
 
566
Item* Item::compile(Item_analyzer analyzer, 
 
567
                    unsigned char **arg_p,
 
568
                    Item_transformer transformer, 
 
569
                    unsigned char *arg_t)
 
570
{
 
571
  if ((this->*analyzer) (arg_p))
 
572
    return ((this->*transformer) (arg_t));
 
573
  return NULL;
 
574
}
 
575
 
 
576
void Item::traverse_cond(Cond_traverser traverser, void *arg, traverse_order)
 
577
{
 
578
  (*traverser)(this, arg);
 
579
}
 
580
 
 
581
bool Item::remove_dependence_processor(unsigned char *)
 
582
{
 
583
  return false;
 
584
}
 
585
 
 
586
bool Item::remove_fixed(unsigned char *)
 
587
{
 
588
  fixed= false;
 
589
  return false;
 
590
}
 
591
 
 
592
bool Item::collect_item_field_processor(unsigned char *)
 
593
{
 
594
  return false;
 
595
}
 
596
 
 
597
bool Item::find_item_in_field_list_processor(unsigned char *)
 
598
{
 
599
  return false;
 
600
}
 
601
 
 
602
bool Item::change_context_processor(unsigned char *)
 
603
{
 
604
  return false;
 
605
}
 
606
 
 
607
bool Item::reset_query_id_processor(unsigned char *)
 
608
{
 
609
  return false;
 
610
}
 
611
 
 
612
bool Item::register_field_in_read_map(unsigned char *)
 
613
{
 
614
  return false;
 
615
}
 
616
 
 
617
bool Item::subst_argument_checker(unsigned char **arg)
 
618
{
 
619
  if (*arg)
 
620
    *arg= NULL;
 
621
  return true;
 
622
}
 
623
 
 
624
Item *Item::equal_fields_propagator(unsigned char *)
 
625
{
 
626
  return this;
 
627
}
 
628
 
 
629
bool Item::set_no_const_sub(unsigned char *)
 
630
{
 
631
  return false;
 
632
}
 
633
 
 
634
Item *Item::replace_equal_field(unsigned char *)
 
635
{
 
636
  return this;
 
637
}
 
638
 
 
639
uint32_t Item::cols()
 
640
{
 
641
  return 1;
 
642
}
 
643
 
 
644
Item* Item::element_index(uint32_t)
 
645
{
 
646
  return this;
 
647
}
 
648
 
 
649
Item** Item::addr(uint32_t)
 
650
{
 
651
  return NULL;
 
652
}
 
653
 
 
654
bool Item::null_inside()
 
655
{
 
656
  return false;
 
657
}
 
658
 
 
659
void Item::bring_value()
 
660
{}
 
661
 
 
662
Item *Item::neg_transformer(Session *)
 
663
{
 
664
  return NULL;
 
665
}
 
666
 
 
667
Item *Item::update_value_transformer(unsigned char *)
 
668
{
 
669
  return this;
 
670
}
 
671
 
 
672
void Item::delete_self()
 
673
{
 
674
  cleanup();
 
675
  delete this;
 
676
}
 
677
 
 
678
bool Item::result_as_int64_t()
 
679
{
 
680
  return false;
 
681
}
 
682
 
 
683
bool Item::is_expensive()
 
684
{
 
685
  if (is_expensive_cache < 0)
 
686
    is_expensive_cache= walk(&Item::is_expensive_processor, 0,
 
687
                             (unsigned char*)0);
 
688
  return test(is_expensive_cache);
 
689
}
952
690
 
953
691
int Item::save_in_field_no_warnings(Field *field, bool no_conversions)
954
692
{
955
693
  int res;
956
 
  TABLE *table= field->table;
957
 
  THD *thd= table->in_use;
958
 
  enum_check_fields tmp= thd->count_cuted_fields;
959
 
  my_bitmap_map *old_map= dbug_tmp_use_all_columns(table, table->write_set);
960
 
  ulong sql_mode= thd->variables.sql_mode;
961
 
  thd->variables.sql_mode&= ~(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE);
962
 
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
 
694
  Table *table= field->table;
 
695
  Session *session= table->in_use;
 
696
  enum_check_fields tmp= session->count_cuted_fields;
 
697
  ulong sql_mode= session->variables.sql_mode;
 
698
  session->variables.sql_mode&= ~(MODE_NO_ZERO_DATE);
 
699
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
963
700
  res= save_in_field(field, no_conversions);
964
 
  thd->count_cuted_fields= tmp;
965
 
  dbug_tmp_restore_column_map(table->write_set, old_map);
966
 
  thd->variables.sql_mode= sql_mode;
 
701
  session->count_cuted_fields= tmp;
 
702
  session->variables.sql_mode= sql_mode;
967
703
  return res;
968
704
}
969
705
 
970
 
 
971
706
/*
972
 
 need a special class to adjust printing : references to aggregate functions 
 
707
 need a special class to adjust printing : references to aggregate functions
973
708
 must not be printed as refs because the aggregate functions that are added to
974
709
 the front of select list are not printed as well.
975
710
*/
989
724
  }
990
725
};
991
726
 
992
 
 
993
 
/**
994
 
  Move SUM items out from item tree and replace with reference.
995
 
 
996
 
  @param thd                    Thread handler
997
 
  @param ref_pointer_array      Pointer to array of reference fields
998
 
  @param fields         All fields in select
999
 
  @param ref                    Pointer to item
1000
 
  @param skip_registered       <=> function be must skipped for registered
1001
 
                               SUM items
1002
 
 
1003
 
  @note
1004
 
    This is from split_sum_func2() for items that should be split
1005
 
 
1006
 
    All found SUM items are added FIRST in the fields list and
1007
 
    we replace the item with a reference.
1008
 
 
1009
 
    thd->fatal_error() may be called if we are out of memory
1010
 
*/
1011
 
 
1012
 
void Item::split_sum_func2(THD *thd, Item **ref_pointer_array,
1013
 
                           List<Item> &fields, Item **ref, 
1014
 
                           bool skip_registered)
 
727
void Item::split_sum_func(Session *session, Item **ref_pointer_array,
 
728
                          List<Item> &fields, Item **ref,
 
729
                          bool skip_registered)
1015
730
{
1016
 
  /* An item of type Item_sum  is registered <=> ref_by != 0 */ 
1017
 
  if (type() == SUM_FUNC_ITEM && skip_registered && 
 
731
  /* An item of type Item_sum  is registered <=> ref_by != 0 */
 
732
  if (type() == SUM_FUNC_ITEM && 
 
733
      skip_registered &&
1018
734
      ((Item_sum *) this)->ref_by)
1019
 
    return;                                                 
 
735
    return;
 
736
 
1020
737
  if ((type() != SUM_FUNC_ITEM && with_sum_func) ||
1021
738
      (type() == FUNC_ITEM &&
1022
739
       (((Item_func *) this)->functype() == Item_func::ISNOTNULLTEST_FUNC ||
1023
740
        ((Item_func *) this)->functype() == Item_func::TRIG_COND_FUNC)))
1024
741
  {
1025
742
    /* Will split complicated items and ignore simple ones */
1026
 
    split_sum_func(thd, ref_pointer_array, fields);
 
743
    split_sum_func(session, ref_pointer_array, fields);
1027
744
  }
1028
745
  else if ((type() == SUM_FUNC_ITEM || (used_tables() & ~PARAM_TABLE_BIT)) &&
1029
746
           type() != SUBSELECT_ITEM &&
1030
 
           (type() != REF_ITEM ||
1031
 
           ((Item_ref*)this)->ref_type() == Item_ref::VIEW_REF))
 
747
           type() != REF_ITEM)
1032
748
  {
1033
749
    /*
1034
750
      Replace item with a reference so that we can easily calculate
1041
757
      Item_ref to allow fields from view being stored in tmp table.
1042
758
    */
1043
759
    Item_aggregate_ref *item_ref;
1044
 
    uint el= fields.elements;
 
760
    uint32_t el= fields.elements;
1045
761
    Item *real_itm= real_item();
1046
762
 
1047
763
    ref_pointer_array[el]= real_itm;
1048
 
    if (!(item_ref= new Item_aggregate_ref(&thd->lex->current_select->context,
 
764
    if (!(item_ref= new Item_aggregate_ref(&session->lex->current_select->context,
1049
765
                                           ref_pointer_array + el, 0, name)))
1050
 
      return;                                   // fatal_error is set
 
766
      return; /* fatal_error is set */
1051
767
    if (type() == SUM_FUNC_ITEM)
1052
 
      item_ref->depended_from= ((Item_sum *) this)->depended_from(); 
 
768
      item_ref->depended_from= ((Item_sum *) this)->depended_from();
1053
769
    fields.push_front(real_itm);
1054
 
    thd->change_item_tree(ref, item_ref);
1055
 
  }
1056
 
}
1057
 
 
1058
 
 
1059
 
static bool
1060
 
left_is_superset(DTCollation *left, DTCollation *right)
1061
 
{
1062
 
  /* Allow convert to Unicode */
1063
 
  if (left->collation->state & MY_CS_UNICODE &&
1064
 
      (left->derivation < right->derivation ||
1065
 
       (left->derivation == right->derivation &&
1066
 
        !(right->collation->state & MY_CS_UNICODE))))
1067
 
    return true;
1068
 
  /* Allow convert from ASCII */
1069
 
  if (right->repertoire == MY_REPERTOIRE_ASCII &&
1070
 
      (left->derivation < right->derivation ||
1071
 
       (left->derivation == right->derivation &&
1072
 
        !(left->repertoire == MY_REPERTOIRE_ASCII))))
1073
 
    return true;
1074
 
  /* Disallow conversion otherwise */
1075
 
  return false;
1076
 
}
1077
 
 
1078
 
/**
1079
 
  Aggregate two collations together taking
1080
 
  into account their coercibility (aka derivation):.
1081
 
 
1082
 
  0 == DERIVATION_EXPLICIT  - an explicitly written COLLATE clause @n
1083
 
  1 == DERIVATION_NONE      - a mix of two different collations @n
1084
 
  2 == DERIVATION_IMPLICIT  - a column @n
1085
 
  3 == DERIVATION_COERCIBLE - a string constant.
1086
 
 
1087
 
  The most important rules are:
1088
 
  -# If collations are the same:
1089
 
  chose this collation, and the strongest derivation.
1090
 
  -# If collations are different:
1091
 
  - Character sets may differ, but only if conversion without
1092
 
  data loss is possible. The caller provides flags whether
1093
 
  character set conversion attempts should be done. If no
1094
 
  flags are substituted, then the character sets must be the same.
1095
 
  Currently processed flags are:
1096
 
  MY_COLL_ALLOW_SUPERSET_CONV  - allow conversion to a superset
1097
 
  MY_COLL_ALLOW_COERCIBLE_CONV - allow conversion of a coercible value
1098
 
  - two EXPLICIT collations produce an error, e.g. this is wrong:
1099
 
  CONCAT(expr1 collate latin1_swedish_ci, expr2 collate latin1_german_ci)
1100
 
  - the side with smaller derivation value wins,
1101
 
  i.e. a column is stronger than a string constant,
1102
 
  an explicit COLLATE clause is stronger than a column.
1103
 
  - if derivations are the same, we have DERIVATION_NONE,
1104
 
  we'll wait for an explicit COLLATE clause which possibly can
1105
 
  come from another argument later: for example, this is valid,
1106
 
  but we don't know yet when collecting the first two arguments:
1107
 
     @code
1108
 
       CONCAT(latin1_swedish_ci_column,
1109
 
              latin1_german1_ci_column,
1110
 
              expr COLLATE latin1_german2_ci)
1111
 
  @endcode
1112
 
*/
1113
 
 
1114
 
bool DTCollation::aggregate(DTCollation &dt, uint flags)
1115
 
{
1116
 
  if (!my_charset_same(collation, dt.collation))
1117
 
  {
1118
 
    /* 
1119
 
       We do allow to use binary strings (like BLOBS)
1120
 
       together with character strings.
1121
 
       Binaries have more precedence than a character
1122
 
       string of the same derivation.
1123
 
    */
1124
 
    if (collation == &my_charset_bin)
1125
 
    {
1126
 
      if (derivation <= dt.derivation)
1127
 
        ; // Do nothing
1128
 
      else
1129
 
      {
1130
 
        set(dt); 
1131
 
      }
1132
 
    }
1133
 
    else if (dt.collation == &my_charset_bin)
1134
 
    {
1135
 
      if (dt.derivation <= derivation)
1136
 
      {
1137
 
        set(dt);
1138
 
      }
1139
 
      else
1140
 
      {
1141
 
        // Do nothing
1142
 
      }
1143
 
    }
1144
 
    else if ((flags & MY_COLL_ALLOW_SUPERSET_CONV) &&
1145
 
             left_is_superset(this, &dt))
1146
 
    {
1147
 
      // Do nothing
1148
 
    }
1149
 
    else if ((flags & MY_COLL_ALLOW_SUPERSET_CONV) &&
1150
 
             left_is_superset(&dt, this))
1151
 
    {
1152
 
      set(dt);
1153
 
    }
1154
 
    else if ((flags & MY_COLL_ALLOW_COERCIBLE_CONV) &&
1155
 
             derivation < dt.derivation &&
1156
 
             dt.derivation >= DERIVATION_SYSCONST)
1157
 
    {
1158
 
      // Do nothing;
1159
 
    }
1160
 
    else if ((flags & MY_COLL_ALLOW_COERCIBLE_CONV) &&
1161
 
             dt.derivation < derivation &&
1162
 
             derivation >= DERIVATION_SYSCONST)
1163
 
    {
1164
 
      set(dt);
1165
 
    }
1166
 
    else
1167
 
    {
1168
 
      // Cannot apply conversion
1169
 
      set(0, DERIVATION_NONE, 0);
1170
 
      return 1;
1171
 
    }
1172
 
  }
1173
 
  else if (derivation < dt.derivation)
1174
 
  {
1175
 
    // Do nothing
1176
 
  }
1177
 
  else if (dt.derivation < derivation)
1178
 
  {
1179
 
    set(dt);
1180
 
  }
1181
 
  else
1182
 
  { 
1183
 
    if (collation == dt.collation)
1184
 
    {
1185
 
      // Do nothing
1186
 
    }
1187
 
    else 
1188
 
    {
1189
 
      if (derivation == DERIVATION_EXPLICIT)
1190
 
      {
1191
 
        set(0, DERIVATION_NONE, 0);
1192
 
        return 1;
1193
 
      }
1194
 
      if (collation->state & MY_CS_BINSORT)
1195
 
        return 0;
1196
 
      if (dt.collation->state & MY_CS_BINSORT)
1197
 
      {
1198
 
        set(dt);
1199
 
        return 0;
1200
 
      }
1201
 
      const CHARSET_INFO * const bin= get_charset_by_csname(collation->csname, 
1202
 
                                                            MY_CS_BINSORT,MYF(0));
1203
 
      set(bin, DERIVATION_NONE);
1204
 
    }
1205
 
  }
1206
 
  repertoire|= dt.repertoire;
1207
 
  return 0;
1208
 
}
1209
 
 
1210
 
/******************************/
1211
 
static
1212
 
void my_coll_agg_error(DTCollation &c1, DTCollation &c2, const char *fname)
1213
 
{
1214
 
  my_error(ER_CANT_AGGREGATE_2COLLATIONS,MYF(0),
1215
 
           c1.collation->name,c1.derivation_name(),
1216
 
           c2.collation->name,c2.derivation_name(),
1217
 
           fname);
1218
 
}
1219
 
 
1220
 
 
1221
 
static
1222
 
void my_coll_agg_error(DTCollation &c1, DTCollation &c2, DTCollation &c3,
1223
 
                       const char *fname)
1224
 
{
1225
 
  my_error(ER_CANT_AGGREGATE_3COLLATIONS,MYF(0),
1226
 
           c1.collation->name,c1.derivation_name(),
1227
 
           c2.collation->name,c2.derivation_name(),
1228
 
           c3.collation->name,c3.derivation_name(),
1229
 
           fname);
1230
 
}
1231
 
 
1232
 
 
1233
 
static
1234
 
void my_coll_agg_error(Item** args, uint count, const char *fname,
1235
 
                       int item_sep)
1236
 
{
1237
 
  if (count == 2)
1238
 
    my_coll_agg_error(args[0]->collation, args[item_sep]->collation, fname);
1239
 
  else if (count == 3)
1240
 
    my_coll_agg_error(args[0]->collation, args[item_sep]->collation,
1241
 
                      args[2*item_sep]->collation, fname);
1242
 
  else
1243
 
    my_error(ER_CANT_AGGREGATE_NCOLLATIONS,MYF(0),fname);
1244
 
}
1245
 
 
1246
 
 
1247
 
bool agg_item_collations(DTCollation &c, const char *fname,
1248
 
                         Item **av, uint count, uint flags, int item_sep)
1249
 
{
1250
 
  uint i;
1251
 
  Item **arg;
1252
 
  c.set(av[0]->collation);
1253
 
  for (i= 1, arg= &av[item_sep]; i < count; i++, arg++)
1254
 
  {
1255
 
    if (c.aggregate((*arg)->collation, flags))
1256
 
    {
1257
 
      my_coll_agg_error(av, count, fname, item_sep);
1258
 
      return true;
1259
 
    }
1260
 
  }
1261
 
  if ((flags & MY_COLL_DISALLOW_NONE) &&
1262
 
      c.derivation == DERIVATION_NONE)
1263
 
  {
1264
 
    my_coll_agg_error(av, count, fname, item_sep);
1265
 
    return true;
1266
 
  }
1267
 
  return false;
1268
 
}
1269
 
 
1270
 
 
1271
 
bool agg_item_collations_for_comparison(DTCollation &c, const char *fname,
1272
 
                                        Item **av, uint count, uint flags)
1273
 
{
1274
 
  return (agg_item_collations(c, fname, av, count,
1275
 
                              flags | MY_COLL_DISALLOW_NONE, 1));
1276
 
}
1277
 
 
1278
 
 
1279
 
/**
1280
 
  Collect arguments' character sets together.
1281
 
 
1282
 
  We allow to apply automatic character set conversion in some cases.
1283
 
  The conditions when conversion is possible are:
1284
 
  - arguments A and B have different charsets
1285
 
  - A wins according to coercibility rules
1286
 
    (i.e. a column is stronger than a string constant,
1287
 
     an explicit COLLATE clause is stronger than a column)
1288
 
  - character set of A is either superset for character set of B,
1289
 
    or B is a string constant which can be converted into the
1290
 
    character set of A without data loss.
1291
 
    
1292
 
  If all of the above is true, then it's possible to convert
1293
 
  B into the character set of A, and then compare according
1294
 
  to the collation of A.
1295
 
  
1296
 
  For functions with more than two arguments:
1297
 
  @code
1298
 
    collect(A,B,C) ::= collect(collect(A,B),C)
1299
 
  @endcode
1300
 
  Since this function calls THD::change_item_tree() on the passed Item **
1301
 
  pointers, it is necessary to pass the original Item **'s, not copies.
1302
 
  Otherwise their values will not be properly restored (see BUG#20769).
1303
 
  If the items are not consecutive (eg. args[2] and args[5]), use the
1304
 
  item_sep argument, ie.
1305
 
  @code
1306
 
    agg_item_charsets(coll, fname, &args[2], 2, flags, 3)
1307
 
  @endcode
1308
 
*/
1309
 
 
1310
 
bool agg_item_charsets(DTCollation &coll, const char *fname,
1311
 
                       Item **args, uint nargs, uint flags, int item_sep)
1312
 
{
1313
 
  Item **arg, *safe_args[2];
1314
 
 
1315
 
  memset(safe_args, 0, sizeof(safe_args));
1316
 
 
1317
 
  if (agg_item_collations(coll, fname, args, nargs, flags, item_sep))
1318
 
    return true;
1319
 
 
1320
 
  /*
1321
 
    For better error reporting: save the first and the second argument.
1322
 
    We need this only if the the number of args is 3 or 2:
1323
 
    - for a longer argument list, "Illegal mix of collations"
1324
 
      doesn't display each argument's characteristics.
1325
 
    - if nargs is 1, then this error cannot happen.
1326
 
  */
1327
 
  if (nargs >=2 && nargs <= 3)
1328
 
  {
1329
 
    safe_args[0]= args[0];
1330
 
    safe_args[1]= args[item_sep];
1331
 
  }
1332
 
 
1333
 
  THD *thd= current_thd;
1334
 
  Query_arena *arena, backup;
1335
 
  bool res= false;
1336
 
  uint i;
1337
 
  /*
1338
 
    In case we're in statement prepare, create conversion item
1339
 
    in its memory: it will be reused on each execute.
1340
 
  */
1341
 
  arena= NULL;
1342
 
 
1343
 
  for (i= 0, arg= args; i < nargs; i++, arg+= item_sep)
1344
 
  {
1345
 
    Item* conv;
1346
 
    uint32_t dummy_offset;
1347
 
    if (!String::needs_conversion(0, (*arg)->collation.collation,
1348
 
                                  coll.collation,
1349
 
                                  &dummy_offset))
1350
 
      continue;
1351
 
 
1352
 
    if (!(conv= (*arg)->safe_charset_converter(coll.collation)) &&
1353
 
        ((*arg)->collation.repertoire == MY_REPERTOIRE_ASCII))
1354
 
      conv= new Item_func_conv_charset(*arg, coll.collation, 1);
1355
 
 
1356
 
    if (!conv)
1357
 
    {
1358
 
      if (nargs >=2 && nargs <= 3)
1359
 
      {
1360
 
        /* restore the original arguments for better error message */
1361
 
        args[0]= safe_args[0];
1362
 
        args[item_sep]= safe_args[1];
1363
 
      }
1364
 
      my_coll_agg_error(args, nargs, fname, item_sep);
1365
 
      res= true;
1366
 
      break; // we cannot return here, we need to restore "arena".
1367
 
    }
1368
 
    if ((*arg)->type() == Item::FIELD_ITEM)
1369
 
      ((Item_field *)(*arg))->no_const_subst= 1;
1370
 
    /*
1371
 
      If in statement prepare, then we create a converter for two
1372
 
      constant items, do it once and then reuse it.
1373
 
      If we're in execution of a prepared statement, arena is NULL,
1374
 
      and the conv was created in runtime memory. This can be
1375
 
      the case only if the argument is a parameter marker ('?'),
1376
 
      because for all true constants the charset converter has already
1377
 
      been created in prepare. In this case register the change for
1378
 
      rollback.
1379
 
    */
1380
 
    thd->change_item_tree(arg, conv);
1381
 
    /*
1382
 
      We do not check conv->fixed, because Item_func_conv_charset which can
1383
 
      be return by safe_charset_converter can't be fixed at creation
1384
 
    */
1385
 
    conv->fix_fields(thd, arg);
1386
 
  }
1387
 
  if (arena)
1388
 
    thd->restore_active_arena(arena, &backup);
1389
 
  return res;
1390
 
}
1391
 
 
1392
 
 
1393
 
void Item_ident_for_show::make_field(Send_field *tmp_field)
1394
 
{
1395
 
  tmp_field->table_name= tmp_field->org_table_name= table_name;
1396
 
  tmp_field->db_name= db_name;
1397
 
  tmp_field->col_name= tmp_field->org_col_name= field->field_name;
1398
 
  tmp_field->charsetnr= field->charset()->number;
1399
 
  tmp_field->length=field->field_length;
1400
 
  tmp_field->type=field->type();
1401
 
  tmp_field->flags= field->table->maybe_null ? 
1402
 
    (field->flags & ~NOT_NULL_FLAG) : field->flags;
1403
 
  tmp_field->decimals= field->decimals();
1404
 
}
1405
 
 
1406
 
/**********************************************/
1407
 
 
1408
 
Item_field::Item_field(Field *f)
1409
 
  :Item_ident(0, NullS, *f->table_name, f->field_name),
1410
 
   item_equal(0), no_const_subst(0),
1411
 
   have_privileges(0), any_privileges(0)
1412
 
{
1413
 
  set_field(f);
1414
 
  /*
1415
 
    field_name and table_name should not point to garbage
1416
 
    if this item is to be reused
1417
 
  */
1418
 
  orig_table_name= orig_field_name= "";
1419
 
}
1420
 
 
1421
 
 
1422
 
/**
1423
 
  Constructor used inside setup_wild().
1424
 
 
1425
 
  Ensures that field, table, and database names will live as long as
1426
 
  Item_field (this is important in prepared statements).
1427
 
*/
1428
 
 
1429
 
Item_field::Item_field(THD *thd __attribute__((unused)),
1430
 
                       Name_resolution_context *context_arg,
1431
 
                       Field *f)
1432
 
  :Item_ident(context_arg, f->table->s->db.str, *f->table_name, f->field_name),
1433
 
   item_equal(0), no_const_subst(0),
1434
 
   have_privileges(0), any_privileges(0)
1435
 
{
1436
 
  set_field(f);
1437
 
}
1438
 
 
1439
 
 
1440
 
Item_field::Item_field(Name_resolution_context *context_arg,
1441
 
                       const char *db_arg,const char *table_name_arg,
1442
 
                       const char *field_name_arg)
1443
 
  :Item_ident(context_arg, db_arg,table_name_arg,field_name_arg),
1444
 
   field(0), result_field(0), item_equal(0), no_const_subst(0),
1445
 
   have_privileges(0), any_privileges(0)
1446
 
{
1447
 
  SELECT_LEX *select= current_thd->lex->current_select;
1448
 
  collation.set(DERIVATION_IMPLICIT);
1449
 
  if (select && select->parsing_place != IN_HAVING)
1450
 
      select->select_n_where_fields++;
1451
 
}
1452
 
 
1453
 
/**
1454
 
  Constructor need to process subselect with temporary tables (see Item)
1455
 
*/
1456
 
 
1457
 
Item_field::Item_field(THD *thd, Item_field *item)
1458
 
  :Item_ident(thd, item),
1459
 
   field(item->field),
1460
 
   result_field(item->result_field),
1461
 
   item_equal(item->item_equal),
1462
 
   no_const_subst(item->no_const_subst),
1463
 
   have_privileges(item->have_privileges),
1464
 
   any_privileges(item->any_privileges)
1465
 
{
1466
 
  collation.set(DERIVATION_IMPLICIT);
1467
 
}
1468
 
 
1469
 
void Item_field::set_field(Field *field_par)
1470
 
{
1471
 
  field=result_field=field_par;                 // for easy coding with fields
1472
 
  maybe_null=field->maybe_null();
1473
 
  decimals= field->decimals();
1474
 
  max_length= field_par->max_display_length();
1475
 
  table_name= *field_par->table_name;
1476
 
  field_name= field_par->field_name;
1477
 
  db_name= field_par->table->s->db.str;
1478
 
  alias_name_used= field_par->table->alias_name_used;
1479
 
  unsigned_flag=test(field_par->flags & UNSIGNED_FLAG);
1480
 
  collation.set(field_par->charset(), field_par->derivation());
1481
 
  fixed= 1;
1482
 
  if (field->table->s->tmp_table == SYSTEM_TMP_TABLE)
1483
 
    any_privileges= 0;
1484
 
}
1485
 
 
1486
 
 
1487
 
/**
1488
 
  Reset this item to point to a field from the new temporary table.
1489
 
  This is used when we create a new temporary table for each execution
1490
 
  of prepared statement.
1491
 
*/
1492
 
 
1493
 
void Item_field::reset_field(Field *f)
1494
 
{
1495
 
  set_field(f);
1496
 
  /* 'name' is pointing at field->field_name of old field */
1497
 
  name= (char*) f->field_name;
1498
 
}
1499
 
 
1500
 
const char *Item_ident::full_name() const
1501
 
{
1502
 
  char *tmp;
1503
 
  if (!table_name || !field_name)
1504
 
    return field_name ? field_name : name ? name : "tmp_field";
1505
 
  if (db_name && db_name[0])
1506
 
  {
1507
 
    tmp=(char*) sql_alloc((uint) strlen(db_name)+(uint) strlen(table_name)+
1508
 
                          (uint) strlen(field_name)+3);
1509
 
    strxmov(tmp,db_name,".",table_name,".",field_name,NullS);
1510
 
  }
1511
 
  else
1512
 
  {
1513
 
    if (table_name[0])
1514
 
    {
1515
 
      tmp= (char*) sql_alloc((uint) strlen(table_name) +
1516
 
                             (uint) strlen(field_name) + 2);
1517
 
      strxmov(tmp, table_name, ".", field_name, NullS);
1518
 
    }
1519
 
    else
1520
 
      tmp= (char*) field_name;
1521
 
  }
1522
 
  return tmp;
1523
 
}
1524
 
 
1525
 
void Item_ident::print(String *str,
1526
 
                       enum_query_type query_type __attribute__((unused)))
1527
 
{
1528
 
  THD *thd= current_thd;
1529
 
  char d_name_buff[MAX_ALIAS_NAME], t_name_buff[MAX_ALIAS_NAME];
1530
 
  const char *d_name= db_name, *t_name= table_name;
1531
 
  if (lower_case_table_names== 1 ||
1532
 
      (lower_case_table_names == 2 && !alias_name_used))
1533
 
  {
1534
 
    if (table_name && table_name[0])
1535
 
    {
1536
 
      stpcpy(t_name_buff, table_name);
1537
 
      my_casedn_str(files_charset_info, t_name_buff);
1538
 
      t_name= t_name_buff;
1539
 
    }
1540
 
    if (db_name && db_name[0])
1541
 
    {
1542
 
      stpcpy(d_name_buff, db_name);
1543
 
      my_casedn_str(files_charset_info, d_name_buff);
1544
 
      d_name= d_name_buff;
1545
 
    }
1546
 
  }
1547
 
 
1548
 
  if (!table_name || !field_name || !field_name[0])
1549
 
  {
1550
 
    const char *nm= (field_name && field_name[0]) ?
1551
 
                      field_name : name ? name : "tmp_field";
1552
 
    append_identifier(thd, str, nm, (uint) strlen(nm));
1553
 
    return;
1554
 
  }
1555
 
  if (db_name && db_name[0] && !alias_name_used)
1556
 
  {
1557
 
    {
1558
 
      append_identifier(thd, str, d_name, (uint)strlen(d_name));
1559
 
      str->append('.');
1560
 
    }
1561
 
    append_identifier(thd, str, t_name, (uint)strlen(t_name));
1562
 
    str->append('.');
1563
 
    append_identifier(thd, str, field_name, (uint)strlen(field_name));
1564
 
  }
1565
 
  else
1566
 
  {
1567
 
    if (table_name[0])
1568
 
    {
1569
 
      append_identifier(thd, str, t_name, (uint) strlen(t_name));
1570
 
      str->append('.');
1571
 
      append_identifier(thd, str, field_name, (uint) strlen(field_name));
1572
 
    }
1573
 
    else
1574
 
      append_identifier(thd, str, field_name, (uint) strlen(field_name));
1575
 
  }
1576
 
}
1577
 
 
1578
 
/* ARGSUSED */
1579
 
String *Item_field::val_str(String *str)
1580
 
{
1581
 
  assert(fixed == 1);
1582
 
  if ((null_value=field->is_null()))
1583
 
    return 0;
1584
 
  str->set_charset(str_value.charset());
1585
 
  return field->val_str(str,&str_value);
1586
 
}
1587
 
 
1588
 
 
1589
 
double Item_field::val_real()
1590
 
{
1591
 
  assert(fixed == 1);
1592
 
  if ((null_value=field->is_null()))
1593
 
    return 0.0;
1594
 
  return field->val_real();
1595
 
}
1596
 
 
1597
 
 
1598
 
int64_t Item_field::val_int()
1599
 
{
1600
 
  assert(fixed == 1);
1601
 
  if ((null_value=field->is_null()))
1602
 
    return 0;
1603
 
  return field->val_int();
1604
 
}
1605
 
 
1606
 
 
1607
 
my_decimal *Item_field::val_decimal(my_decimal *decimal_value)
1608
 
{
1609
 
  if ((null_value= field->is_null()))
1610
 
    return 0;
1611
 
  return field->val_decimal(decimal_value);
1612
 
}
1613
 
 
1614
 
 
1615
 
String *Item_field::str_result(String *str)
1616
 
{
1617
 
  if ((null_value=result_field->is_null()))
1618
 
    return 0;
1619
 
  str->set_charset(str_value.charset());
1620
 
  return result_field->val_str(str,&str_value);
1621
 
}
1622
 
 
1623
 
bool Item_field::get_date(DRIZZLE_TIME *ltime,uint fuzzydate)
1624
 
{
1625
 
  if ((null_value=field->is_null()) || field->get_date(ltime,fuzzydate))
1626
 
  {
1627
 
    memset(ltime, 0, sizeof(*ltime));
1628
 
    return 1;
1629
 
  }
1630
 
  return 0;
1631
 
}
1632
 
 
1633
 
bool Item_field::get_date_result(DRIZZLE_TIME *ltime,uint fuzzydate)
1634
 
{
1635
 
  if ((null_value=result_field->is_null()) ||
1636
 
      result_field->get_date(ltime,fuzzydate))
1637
 
  {
1638
 
    memset(ltime, 0, sizeof(*ltime));
1639
 
    return 1;
1640
 
  }
1641
 
  return 0;
1642
 
}
1643
 
 
1644
 
bool Item_field::get_time(DRIZZLE_TIME *ltime)
1645
 
{
1646
 
  if ((null_value=field->is_null()) || field->get_time(ltime))
1647
 
  {
1648
 
    memset(ltime, 0, sizeof(*ltime));
1649
 
    return 1;
1650
 
  }
1651
 
  return 0;
1652
 
}
1653
 
 
1654
 
double Item_field::val_result()
1655
 
{
1656
 
  if ((null_value=result_field->is_null()))
1657
 
    return 0.0;
1658
 
  return result_field->val_real();
1659
 
}
1660
 
 
1661
 
int64_t Item_field::val_int_result()
1662
 
{
1663
 
  if ((null_value=result_field->is_null()))
1664
 
    return 0;
1665
 
  return result_field->val_int();
1666
 
}
1667
 
 
1668
 
 
1669
 
my_decimal *Item_field::val_decimal_result(my_decimal *decimal_value)
1670
 
{
1671
 
  if ((null_value= result_field->is_null()))
1672
 
    return 0;
1673
 
  return result_field->val_decimal(decimal_value);
1674
 
}
1675
 
 
1676
 
 
1677
 
bool Item_field::val_bool_result()
1678
 
{
1679
 
  if ((null_value= result_field->is_null()))
1680
 
    return false;
1681
 
  switch (result_field->result_type()) {
1682
 
  case INT_RESULT:
1683
 
    return result_field->val_int() != 0;
1684
 
  case DECIMAL_RESULT:
1685
 
  {
1686
 
    my_decimal decimal_value;
1687
 
    my_decimal *val= result_field->val_decimal(&decimal_value);
1688
 
    if (val)
1689
 
      return !my_decimal_is_zero(val);
1690
 
    return 0;
1691
 
  }
1692
 
  case REAL_RESULT:
1693
 
  case STRING_RESULT:
1694
 
    return result_field->val_real() != 0.0;
1695
 
  case ROW_RESULT:
1696
 
  default:
1697
 
    assert(0);
1698
 
    return 0;                                   // Shut up compiler
1699
 
  }
1700
 
}
1701
 
 
1702
 
 
1703
 
bool Item_field::eq(const Item *item,
1704
 
                    bool binary_cmp __attribute__((unused))) const
1705
 
{
1706
 
  Item *real_item= ((Item *) item)->real_item();
1707
 
  if (real_item->type() != FIELD_ITEM)
1708
 
    return 0;
1709
 
 
1710
 
  Item_field *item_field= (Item_field*) real_item;
1711
 
  if (item_field->field && field)
1712
 
    return item_field->field == field;
1713
 
  /*
1714
 
    We may come here when we are trying to find a function in a GROUP BY
1715
 
    clause from the select list.
1716
 
    In this case the '100 % correct' way to do this would be to first
1717
 
    run fix_fields() on the GROUP BY item and then retry this function, but
1718
 
    I think it's better to relax the checking a bit as we will in
1719
 
    most cases do the correct thing by just checking the field name.
1720
 
    (In cases where we would choose wrong we would have to generate a
1721
 
    ER_NON_UNIQ_ERROR).
1722
 
  */
1723
 
  return (!my_strcasecmp(system_charset_info, item_field->name,
1724
 
                         field_name) &&
1725
 
          (!item_field->table_name || !table_name ||
1726
 
           (!my_strcasecmp(table_alias_charset, item_field->table_name,
1727
 
                           table_name) &&
1728
 
            (!item_field->db_name || !db_name ||
1729
 
             (item_field->db_name && !strcmp(item_field->db_name,
1730
 
                                             db_name))))));
1731
 
}
1732
 
 
1733
 
 
1734
 
table_map Item_field::used_tables() const
1735
 
{
1736
 
  if (field->table->const_table)
1737
 
    return 0;                                   // const item
1738
 
  return (depended_from ? OUTER_REF_TABLE_BIT : field->table->map);
1739
 
}
1740
 
 
1741
 
 
1742
 
void Item_field::fix_after_pullout(st_select_lex *new_parent,
1743
 
                                   Item **ref __attribute__((unused)))
1744
 
{
1745
 
  if (new_parent == depended_from)
1746
 
    depended_from= NULL;
1747
 
  Name_resolution_context *ctx= new Name_resolution_context();
1748
 
  ctx->outer_context= NULL; // We don't build a complete name resolver
1749
 
  ctx->select_lex= new_parent;
1750
 
  ctx->first_name_resolution_table= context->first_name_resolution_table;
1751
 
  ctx->last_name_resolution_table=  context->last_name_resolution_table;
1752
 
  this->context=ctx;
1753
 
}
1754
 
 
1755
 
 
1756
 
Item *Item_field::get_tmp_table_item(THD *thd)
1757
 
{
1758
 
  Item_field *new_item= new Item_field(thd, this);
1759
 
  if (new_item)
1760
 
    new_item->field= new_item->result_field;
1761
 
  return new_item;
1762
 
}
1763
 
 
1764
 
int64_t Item_field::val_int_endpoint(bool left_endp __attribute__((unused)),
1765
 
                                      bool *incl_endp __attribute__((unused)))
1766
 
{
1767
 
  int64_t res= val_int();
1768
 
  return null_value? INT64_MIN : res;
1769
 
}
1770
 
 
1771
 
/**
1772
 
  Create an item from a string we KNOW points to a valid int64_t
1773
 
  end \\0 terminated number string.
1774
 
  This is always 'signed'. Unsigned values are created with Item_uint()
1775
 
*/
1776
 
 
1777
 
Item_int::Item_int(const char *str_arg, uint length)
1778
 
{
1779
 
  char *end_ptr= (char*) str_arg + length;
1780
 
  int error;
1781
 
  value= my_strtoll10(str_arg, &end_ptr, &error);
1782
 
  max_length= (uint) (end_ptr - str_arg);
1783
 
  name= (char*) str_arg;
1784
 
  fixed= 1;
1785
 
}
1786
 
 
1787
 
 
1788
 
my_decimal *Item_int::val_decimal(my_decimal *decimal_value)
1789
 
{
1790
 
  int2my_decimal(E_DEC_FATAL_ERROR, value, unsigned_flag, decimal_value);
1791
 
  return decimal_value;
1792
 
}
1793
 
 
1794
 
String *Item_int::val_str(String *str)
1795
 
{
1796
 
  // following assert is redundant, because fixed=1 assigned in constructor
1797
 
  assert(fixed == 1);
1798
 
  str->set(value, &my_charset_bin);
1799
 
  return str;
1800
 
}
1801
 
 
1802
 
void Item_int::print(String *str,
1803
 
                     enum_query_type query_type __attribute__((unused)))
1804
 
{
1805
 
  // my_charset_bin is good enough for numbers
1806
 
  str_value.set(value, &my_charset_bin);
1807
 
  str->append(str_value);
1808
 
}
1809
 
 
1810
 
 
1811
 
Item_uint::Item_uint(const char *str_arg, uint length):
1812
 
  Item_int(str_arg, length)
1813
 
{
1814
 
  unsigned_flag= 1;
1815
 
}
1816
 
 
1817
 
 
1818
 
Item_uint::Item_uint(const char *str_arg, int64_t i, uint length):
1819
 
  Item_int(str_arg, i, length)
1820
 
{
1821
 
  unsigned_flag= 1;
1822
 
}
1823
 
 
1824
 
 
1825
 
String *Item_uint::val_str(String *str)
1826
 
{
1827
 
  // following assert is redundant, because fixed=1 assigned in constructor
1828
 
  assert(fixed == 1);
1829
 
  str->set((uint64_t) value, &my_charset_bin);
1830
 
  return str;
1831
 
}
1832
 
 
1833
 
 
1834
 
void Item_uint::print(String *str,
1835
 
                      enum_query_type query_type __attribute__((unused)))
1836
 
{
1837
 
  // latin1 is good enough for numbers
1838
 
  str_value.set((uint64_t) value, default_charset());
1839
 
  str->append(str_value);
1840
 
}
1841
 
 
1842
 
 
1843
 
Item_decimal::Item_decimal(const char *str_arg, uint length,
1844
 
                           const CHARSET_INFO * const charset)
1845
 
{
1846
 
  str2my_decimal(E_DEC_FATAL_ERROR, str_arg, length, charset, &decimal_value);
1847
 
  name= (char*) str_arg;
1848
 
  decimals= (uint8_t) decimal_value.frac;
1849
 
  fixed= 1;
1850
 
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
1851
 
                                             decimals, unsigned_flag);
1852
 
}
1853
 
 
1854
 
Item_decimal::Item_decimal(int64_t val, bool unsig)
1855
 
{
1856
 
  int2my_decimal(E_DEC_FATAL_ERROR, val, unsig, &decimal_value);
1857
 
  decimals= (uint8_t) decimal_value.frac;
1858
 
  fixed= 1;
1859
 
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
1860
 
                                             decimals, unsigned_flag);
1861
 
}
1862
 
 
1863
 
 
1864
 
Item_decimal::Item_decimal(double val,
1865
 
                           int precision __attribute__((unused)),
1866
 
                           int scale __attribute__((unused)))
1867
 
{
1868
 
  double2my_decimal(E_DEC_FATAL_ERROR, val, &decimal_value);
1869
 
  decimals= (uint8_t) decimal_value.frac;
1870
 
  fixed= 1;
1871
 
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
1872
 
                                             decimals, unsigned_flag);
1873
 
}
1874
 
 
1875
 
 
1876
 
Item_decimal::Item_decimal(const char *str, const my_decimal *val_arg,
1877
 
                           uint decimal_par, uint length)
1878
 
{
1879
 
  my_decimal2decimal(val_arg, &decimal_value);
1880
 
  name= (char*) str;
1881
 
  decimals= (uint8_t) decimal_par;
1882
 
  max_length= length;
1883
 
  fixed= 1;
1884
 
}
1885
 
 
1886
 
 
1887
 
Item_decimal::Item_decimal(my_decimal *value_par)
1888
 
{
1889
 
  my_decimal2decimal(value_par, &decimal_value);
1890
 
  decimals= (uint8_t) decimal_value.frac;
1891
 
  fixed= 1;
1892
 
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
1893
 
                                             decimals, unsigned_flag);
1894
 
}
1895
 
 
1896
 
 
1897
 
Item_decimal::Item_decimal(const uchar *bin, int precision, int scale)
1898
 
{
1899
 
  binary2my_decimal(E_DEC_FATAL_ERROR, bin,
1900
 
                    &decimal_value, precision, scale);
1901
 
  decimals= (uint8_t) decimal_value.frac;
1902
 
  fixed= 1;
1903
 
  max_length= my_decimal_precision_to_length(precision, decimals,
1904
 
                                             unsigned_flag);
1905
 
}
1906
 
 
1907
 
 
1908
 
int64_t Item_decimal::val_int()
1909
 
{
1910
 
  int64_t result;
1911
 
  my_decimal2int(E_DEC_FATAL_ERROR, &decimal_value, unsigned_flag, &result);
1912
 
  return result;
1913
 
}
1914
 
 
1915
 
double Item_decimal::val_real()
1916
 
{
1917
 
  double result;
1918
 
  my_decimal2double(E_DEC_FATAL_ERROR, &decimal_value, &result);
1919
 
  return result;
1920
 
}
1921
 
 
1922
 
String *Item_decimal::val_str(String *result)
1923
 
{
1924
 
  result->set_charset(&my_charset_bin);
1925
 
  my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value, 0, 0, 0, result);
1926
 
  return result;
1927
 
}
1928
 
 
1929
 
void Item_decimal::print(String *str,
1930
 
                         enum_query_type query_type __attribute__((unused)))
1931
 
{
1932
 
  my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value, 0, 0, 0, &str_value);
1933
 
  str->append(str_value);
1934
 
}
1935
 
 
1936
 
 
1937
 
bool Item_decimal::eq(const Item *item,
1938
 
                      bool binary_cmp __attribute__((unused))) const
1939
 
{
1940
 
  if (type() == item->type() && item->basic_const_item())
1941
 
  {
1942
 
    /*
1943
 
      We need to cast off const to call val_decimal(). This should
1944
 
      be OK for a basic constant. Additionally, we can pass 0 as
1945
 
      a true decimal constant will return its internal decimal
1946
 
      storage and ignore the argument.
1947
 
    */
1948
 
    Item *arg= (Item*) item;
1949
 
    my_decimal *value= arg->val_decimal(0);
1950
 
    return !my_decimal_cmp(&decimal_value, value);
1951
 
  }
1952
 
  return 0;
1953
 
}
1954
 
 
1955
 
 
1956
 
void Item_decimal::set_decimal_value(my_decimal *value_par)
1957
 
{
1958
 
  my_decimal2decimal(value_par, &decimal_value);
1959
 
  decimals= (uint8_t) decimal_value.frac;
1960
 
  unsigned_flag= !decimal_value.sign();
1961
 
  max_length= my_decimal_precision_to_length(decimal_value.intg + decimals,
1962
 
                                             decimals, unsigned_flag);
1963
 
}
1964
 
 
1965
 
 
1966
 
String *Item_float::val_str(String *str)
1967
 
{
1968
 
  // following assert is redundant, because fixed=1 assigned in constructor
1969
 
  assert(fixed == 1);
1970
 
  str->set_real(value,decimals,&my_charset_bin);
1971
 
  return str;
1972
 
}
1973
 
 
1974
 
 
1975
 
my_decimal *Item_float::val_decimal(my_decimal *decimal_value)
1976
 
{
1977
 
  // following assert is redundant, because fixed=1 assigned in constructor
1978
 
  assert(fixed == 1);
1979
 
  double2my_decimal(E_DEC_FATAL_ERROR, value, decimal_value);
1980
 
  return (decimal_value);
1981
 
}
1982
 
 
1983
 
 
1984
 
void Item_string::print(String *str, enum_query_type query_type)
1985
 
{
1986
 
  if (query_type == QT_ORDINARY && is_cs_specified())
1987
 
  {
1988
 
    str->append('_');
1989
 
    str->append(collation.collation->csname);
1990
 
  }
1991
 
 
1992
 
  str->append('\'');
1993
 
 
1994
 
  if (query_type == QT_ORDINARY ||
1995
 
      my_charset_same(str_value.charset(), system_charset_info))
1996
 
  {
1997
 
    str_value.print(str);
1998
 
  }
1999
 
  else
2000
 
  {
2001
 
    THD *thd= current_thd;
2002
 
    LEX_STRING utf8_lex_str;
2003
 
 
2004
 
    thd->convert_string(&utf8_lex_str,
2005
 
                        system_charset_info,
2006
 
                        str_value.c_ptr_safe(),
2007
 
                        str_value.length(),
2008
 
                        str_value.charset());
2009
 
 
2010
 
    String utf8_str(utf8_lex_str.str,
2011
 
                    utf8_lex_str.length,
2012
 
                    system_charset_info);
2013
 
 
2014
 
    utf8_str.print(str);
2015
 
  }
2016
 
 
2017
 
  str->append('\'');
2018
 
}
2019
 
 
2020
 
 
2021
 
double Item_string::val_real()
2022
 
{
2023
 
  assert(fixed == 1);
2024
 
  int error;
2025
 
  char *end, *org_end;
2026
 
  double tmp;
2027
 
  const CHARSET_INFO * const cs= str_value.charset();
2028
 
 
2029
 
  org_end= (char*) str_value.ptr() + str_value.length();
2030
 
  tmp= my_strntod(cs, (char*) str_value.ptr(), str_value.length(), &end,
2031
 
                  &error);
2032
 
  if (error || (end != org_end && !check_if_only_end_space(cs, end, org_end)))
2033
 
  {
2034
 
    /*
2035
 
      We can use str_value.ptr() here as Item_string is gurantee to put an
2036
 
      end \0 here.
2037
 
    */
2038
 
    push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
2039
 
                        ER_TRUNCATED_WRONG_VALUE,
2040
 
                        ER(ER_TRUNCATED_WRONG_VALUE), "DOUBLE",
2041
 
                        str_value.ptr());
2042
 
  }
2043
 
  return tmp;
2044
 
}
2045
 
 
2046
 
 
2047
 
/**
2048
 
  @todo
2049
 
  Give error if we wanted a signed integer and we got an unsigned one
2050
 
*/
2051
 
int64_t Item_string::val_int()
2052
 
{
2053
 
  assert(fixed == 1);
2054
 
  int err;
2055
 
  int64_t tmp;
2056
 
  char *end= (char*) str_value.ptr()+ str_value.length();
2057
 
  char *org_end= end;
2058
 
  const CHARSET_INFO * const cs= str_value.charset();
2059
 
 
2060
 
  tmp= (*(cs->cset->strtoll10))(cs, str_value.ptr(), &end, &err);
2061
 
  /*
2062
 
    TODO: Give error if we wanted a signed integer and we got an unsigned
2063
 
    one
2064
 
  */
2065
 
  if (err > 0 ||
2066
 
      (end != org_end && !check_if_only_end_space(cs, end, org_end)))
2067
 
  {
2068
 
    push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
2069
 
                        ER_TRUNCATED_WRONG_VALUE,
2070
 
                        ER(ER_TRUNCATED_WRONG_VALUE), "INTEGER",
2071
 
                        str_value.ptr());
2072
 
  }
2073
 
  return tmp;
2074
 
}
2075
 
 
2076
 
 
2077
 
my_decimal *Item_string::val_decimal(my_decimal *decimal_value)
2078
 
{
2079
 
  return val_decimal_from_string(decimal_value);
2080
 
}
2081
 
 
2082
 
 
2083
 
bool Item_null::eq(const Item *item,
2084
 
                   bool binary_cmp __attribute__((unused))) const
2085
 
{ return item->type() == type(); }
2086
 
 
2087
 
 
2088
 
double Item_null::val_real()
2089
 
{
2090
 
  // following assert is redundant, because fixed=1 assigned in constructor
2091
 
  assert(fixed == 1);
2092
 
  null_value=1;
2093
 
  return 0.0;
2094
 
}
2095
 
int64_t Item_null::val_int()
2096
 
{
2097
 
  // following assert is redundant, because fixed=1 assigned in constructor
2098
 
  assert(fixed == 1);
2099
 
  null_value=1;
2100
 
  return 0;
2101
 
}
2102
 
/* ARGSUSED */
2103
 
String *Item_null::val_str(String *str __attribute__((unused)))
2104
 
{
2105
 
  // following assert is redundant, because fixed=1 assigned in constructor
2106
 
  assert(fixed == 1);
2107
 
  null_value=1;
2108
 
  return 0;
2109
 
}
2110
 
 
2111
 
my_decimal *Item_null::val_decimal(my_decimal *decimal_value __attribute__((unused)))
2112
 
{
2113
 
  return 0;
2114
 
}
2115
 
 
2116
 
 
2117
 
Item *Item_null::safe_charset_converter(const CHARSET_INFO * const tocs)
2118
 
{
2119
 
  collation.set(tocs);
2120
 
  return this;
2121
 
}
2122
 
 
2123
 
/*********************** Item_param related ******************************/
2124
 
 
2125
 
/** 
2126
 
  Default function of Item_param::set_param_func, so in case
2127
 
  of malformed packet the server won't SIGSEGV.
2128
 
*/
2129
 
 
2130
 
static void
2131
 
default_set_param_func(Item_param *param,
2132
 
                       uchar **pos __attribute__((unused)),
2133
 
                       ulong len __attribute__((unused)))
2134
 
{
2135
 
  param->set_null();
2136
 
}
2137
 
 
2138
 
 
2139
 
Item_param::Item_param(uint pos_in_query_arg) :
2140
 
  state(NO_VALUE),
2141
 
  item_result_type(STRING_RESULT),
2142
 
  /* Don't pretend to be a literal unless value for this item is set. */
2143
 
  item_type(PARAM_ITEM),
2144
 
  param_type(DRIZZLE_TYPE_VARCHAR),
2145
 
  pos_in_query(pos_in_query_arg),
2146
 
  set_param_func(default_set_param_func),
2147
 
  limit_clause_param(false)
2148
 
{
2149
 
  name= (char*) "?";
2150
 
  /* 
2151
 
    Since we can't say whenever this item can be NULL or cannot be NULL
2152
 
    before mysql_stmt_execute(), so we assuming that it can be NULL until
2153
 
    value is set.
2154
 
  */
2155
 
  maybe_null= 1;
2156
 
  cnvitem= new Item_string("", 0, &my_charset_bin, DERIVATION_COERCIBLE);
2157
 
  cnvstr.set(cnvbuf, sizeof(cnvbuf), &my_charset_bin);
2158
 
}
2159
 
 
2160
 
 
2161
 
void Item_param::set_null()
2162
 
{
2163
 
  /* These are cleared after each execution by reset() method */
2164
 
  null_value= 1;
2165
 
  /* 
2166
 
    Because of NULL and string values we need to set max_length for each new
2167
 
    placeholder value: user can submit NULL for any placeholder type, and 
2168
 
    string length can be different in each execution.
2169
 
  */
2170
 
  max_length= 0;
2171
 
  decimals= 0;
2172
 
  state= NULL_VALUE;
2173
 
  item_type= Item::NULL_ITEM;
2174
 
  return;
2175
 
}
2176
 
 
2177
 
void Item_param::set_int(int64_t i, uint32_t max_length_arg)
2178
 
{
2179
 
  value.integer= (int64_t) i;
2180
 
  state= INT_VALUE;
2181
 
  max_length= max_length_arg;
2182
 
  decimals= 0;
2183
 
  maybe_null= 0;
2184
 
  return;
2185
 
}
2186
 
 
2187
 
void Item_param::set_double(double d)
2188
 
{
2189
 
  value.real= d;
2190
 
  state= REAL_VALUE;
2191
 
  max_length= DBL_DIG + 8;
2192
 
  decimals= NOT_FIXED_DEC;
2193
 
  maybe_null= 0;
2194
 
  return;
2195
 
}
2196
 
 
2197
 
 
2198
 
/**
2199
 
  Set decimal parameter value from string.
2200
 
 
2201
 
  @param str      character string
2202
 
  @param length   string length
2203
 
 
2204
 
  @note
2205
 
    As we use character strings to send decimal values in
2206
 
    binary protocol, we use str2my_decimal to convert it to
2207
 
    internal decimal value.
2208
 
*/
2209
 
 
2210
 
void Item_param::set_decimal(char *str, ulong length)
2211
 
{
2212
 
  char *end;
2213
 
 
2214
 
  end= str+length;
2215
 
  str2my_decimal((uint)E_DEC_FATAL_ERROR, str, &decimal_value, &end);
2216
 
  state= DECIMAL_VALUE;
2217
 
  decimals= decimal_value.frac;
2218
 
  max_length= my_decimal_precision_to_length(decimal_value.precision(),
2219
 
                                             decimals, unsigned_flag);
2220
 
  maybe_null= 0;
2221
 
  return;
2222
 
}
2223
 
 
2224
 
 
2225
 
/**
2226
 
  Set parameter value from DRIZZLE_TIME value.
2227
 
 
2228
 
  @param tm              datetime value to set (time_type is ignored)
2229
 
  @param type            type of datetime value
2230
 
  @param max_length_arg  max length of datetime value as string
2231
 
 
2232
 
  @note
2233
 
    If we value to be stored is not normalized, zero value will be stored
2234
 
    instead and proper warning will be produced. This function relies on
2235
 
    the fact that even wrong value sent over binary protocol fits into
2236
 
    MAX_DATE_STRING_REP_LENGTH buffer.
2237
 
*/
2238
 
void Item_param::set_time(DRIZZLE_TIME *tm, timestamp_type time_type,
2239
 
                          uint32_t max_length_arg)
2240
 
{ 
2241
 
  value.time= *tm;
2242
 
  value.time.time_type= time_type;
2243
 
 
2244
 
  if (value.time.year > 9999 || value.time.month > 12 ||
2245
 
      value.time.day > 31 ||
2246
 
      ((time_type != DRIZZLE_TIMESTAMP_TIME) && value.time.hour > 23) ||
2247
 
      value.time.minute > 59 || value.time.second > 59)
2248
 
  {
2249
 
    char buff[MAX_DATE_STRING_REP_LENGTH];
2250
 
    uint length= my_TIME_to_str(&value.time, buff);
2251
 
    make_truncated_value_warning(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
2252
 
                                 buff, length, time_type, 0);
2253
 
    set_zero_time(&value.time, DRIZZLE_TIMESTAMP_ERROR);
2254
 
  }
2255
 
 
2256
 
  state= TIME_VALUE;
2257
 
  maybe_null= 0;
2258
 
  max_length= max_length_arg;
2259
 
  decimals= 0;
2260
 
  return;
2261
 
}
2262
 
 
2263
 
 
2264
 
bool Item_param::set_str(const char *str, ulong length)
2265
 
{
2266
 
  /*
2267
 
    Assign string with no conversion: data is converted only after it's
2268
 
    been written to the binary log.
2269
 
  */
2270
 
  uint dummy_errors;
2271
 
  if (str_value.copy(str, length, &my_charset_bin, &my_charset_bin,
2272
 
                     &dummy_errors))
2273
 
    return(true);
2274
 
  state= STRING_VALUE;
2275
 
  max_length= length;
2276
 
  maybe_null= 0;
2277
 
  /* max_length and decimals are set after charset conversion */
2278
 
  /* sic: str may be not null-terminated */
2279
 
  return(false);
2280
 
}
2281
 
 
2282
 
 
2283
 
bool Item_param::set_longdata(const char *str, ulong length)
2284
 
{
2285
 
  /*
2286
 
    If client character set is multibyte, end of long data packet
2287
 
    may hit at the middle of a multibyte character.  Additionally,
2288
 
    if binary log is open we must write long data value to the
2289
 
    binary log in character set of client. This is why we can't
2290
 
    convert long data to connection character set as it comes
2291
 
    (here), and first have to concatenate all pieces together,
2292
 
    write query to the binary log and only then perform conversion.
2293
 
  */
2294
 
  if (str_value.append(str, length, &my_charset_bin))
2295
 
    return(true);
2296
 
  state= LONG_DATA_VALUE;
2297
 
  maybe_null= 0;
2298
 
 
2299
 
  return(false);
2300
 
}
2301
 
 
2302
 
 
2303
 
/**
2304
 
  Set parameter value from user variable value.
2305
 
 
2306
 
  @param thd   Current thread
2307
 
  @param entry User variable structure (NULL means use NULL value)
2308
 
 
2309
 
  @retval
2310
 
    0 OK
2311
 
  @retval
2312
 
    1 Out of memory
2313
 
*/
2314
 
 
2315
 
bool Item_param::set_from_user_var(THD *thd, const user_var_entry *entry)
2316
 
{
2317
 
  if (entry && entry->value)
2318
 
  {
2319
 
    item_result_type= entry->type;
2320
 
    unsigned_flag= entry->unsigned_flag;
2321
 
    if (limit_clause_param)
2322
 
    {
2323
 
      bool unused;
2324
 
      set_int(entry->val_int(&unused), MY_INT64_NUM_DECIMAL_DIGITS);
2325
 
      item_type= Item::INT_ITEM;
2326
 
      return(!unsigned_flag && value.integer < 0 ? 1 : 0);
2327
 
    }
2328
 
    switch (item_result_type) {
2329
 
    case REAL_RESULT:
2330
 
      set_double(*(double*)entry->value);
2331
 
      item_type= Item::REAL_ITEM;
2332
 
      break;
2333
 
    case INT_RESULT:
2334
 
      set_int(*(int64_t*)entry->value, MY_INT64_NUM_DECIMAL_DIGITS);
2335
 
      item_type= Item::INT_ITEM;
2336
 
      break;
2337
 
    case STRING_RESULT:
2338
 
    {
2339
 
      const CHARSET_INFO * const fromcs= entry->collation.collation;
2340
 
      const CHARSET_INFO * const tocs= thd->variables.collation_connection;
2341
 
      uint32_t dummy_offset;
2342
 
 
2343
 
      value.cs_info.character_set_of_placeholder= 
2344
 
        value.cs_info.character_set_client= fromcs;
2345
 
      /*
2346
 
        Setup source and destination character sets so that they
2347
 
        are different only if conversion is necessary: this will
2348
 
        make later checks easier.
2349
 
      */
2350
 
      value.cs_info.final_character_set_of_str_value=
2351
 
        String::needs_conversion(0, fromcs, tocs, &dummy_offset) ?
2352
 
        tocs : fromcs;
2353
 
      /*
2354
 
        Exact value of max_length is not known unless data is converted to
2355
 
        charset of connection, so we have to set it later.
2356
 
      */
2357
 
      item_type= Item::STRING_ITEM;
2358
 
 
2359
 
      if (set_str((const char *)entry->value, entry->length))
2360
 
        return(1);
2361
 
      break;
2362
 
    }
2363
 
    case DECIMAL_RESULT:
2364
 
    {
2365
 
      const my_decimal *ent_value= (const my_decimal *)entry->value;
2366
 
      my_decimal2decimal(ent_value, &decimal_value);
2367
 
      state= DECIMAL_VALUE;
2368
 
      decimals= ent_value->frac;
2369
 
      max_length= my_decimal_precision_to_length(ent_value->precision(),
2370
 
                                                 decimals, unsigned_flag);
2371
 
      item_type= Item::DECIMAL_ITEM;
2372
 
      break;
2373
 
    }
2374
 
    default:
2375
 
      assert(0);
2376
 
      set_null();
2377
 
    }
2378
 
  }
2379
 
  else
2380
 
    set_null();
2381
 
 
2382
 
  return(0);
2383
 
}
2384
 
 
2385
 
/**
2386
 
  Resets parameter after execution.
2387
 
 
2388
 
  @note
2389
 
    We clear null_value here instead of setting it in set_* methods,
2390
 
    because we want more easily handle case for long data.
2391
 
*/
2392
 
 
2393
 
void Item_param::reset()
2394
 
{
2395
 
  /* Shrink string buffer if it's bigger than max possible CHAR column */
2396
 
  if (str_value.alloced_length() > MAX_CHAR_WIDTH)
2397
 
    str_value.free();
2398
 
  else
2399
 
    str_value.length(0);
2400
 
  str_value_ptr.length(0);
2401
 
  /*
2402
 
    We must prevent all charset conversions until data has been written
2403
 
    to the binary log.
2404
 
  */
2405
 
  str_value.set_charset(&my_charset_bin);
2406
 
  collation.set(&my_charset_bin, DERIVATION_COERCIBLE);
2407
 
  state= NO_VALUE;
2408
 
  maybe_null= 1;
2409
 
  null_value= 0;
2410
 
  /*
2411
 
    Don't reset item_type to PARAM_ITEM: it's only needed to guard
2412
 
    us from item optimizations at prepare stage, when item doesn't yet
2413
 
    contain a literal of some kind.
2414
 
    In all other cases when this object is accessed its value is
2415
 
    set (this assumption is guarded by 'state' and
2416
 
    assertS(state != NO_VALUE) in all Item_param::get_*
2417
 
    methods).
2418
 
  */
2419
 
  return;
2420
 
}
2421
 
 
2422
 
 
2423
 
int Item_param::save_in_field(Field *field, bool no_conversions)
2424
 
{
2425
 
  field->set_notnull();
2426
 
 
2427
 
  switch (state) {
2428
 
  case INT_VALUE:
2429
 
    return field->store(value.integer, unsigned_flag);
2430
 
  case REAL_VALUE:
2431
 
    return field->store(value.real);
2432
 
  case DECIMAL_VALUE:
2433
 
    return field->store_decimal(&decimal_value);
2434
 
  case TIME_VALUE:
2435
 
    field->store_time(&value.time, value.time.time_type);
2436
 
    return 0;
2437
 
  case STRING_VALUE:
2438
 
  case LONG_DATA_VALUE:
2439
 
    return field->store(str_value.ptr(), str_value.length(),
2440
 
                        str_value.charset());
2441
 
  case NULL_VALUE:
2442
 
    return set_field_to_null_with_conversions(field, no_conversions);
2443
 
  case NO_VALUE:
2444
 
  default:
2445
 
    assert(0);
2446
 
  }
2447
 
  return 1;
2448
 
}
2449
 
 
2450
 
 
2451
 
bool Item_param::get_time(DRIZZLE_TIME *res)
2452
 
{
2453
 
  if (state == TIME_VALUE)
2454
 
  {
2455
 
    *res= value.time;
2456
 
    return 0;
2457
 
  }
2458
 
  /*
2459
 
    If parameter value isn't supplied assertion will fire in val_str()
2460
 
    which is called from Item::get_time().
2461
 
  */
2462
 
  return Item::get_time(res);
2463
 
}
2464
 
 
2465
 
 
2466
 
bool Item_param::get_date(DRIZZLE_TIME *res, uint fuzzydate)
2467
 
{
2468
 
  if (state == TIME_VALUE)
2469
 
  {
2470
 
    *res= value.time;
2471
 
    return 0;
2472
 
  }
2473
 
  return Item::get_date(res, fuzzydate);
2474
 
}
2475
 
 
2476
 
 
2477
 
double Item_param::val_real()
2478
 
{
2479
 
  switch (state) {
2480
 
  case REAL_VALUE:
2481
 
    return value.real;
2482
 
  case INT_VALUE:
2483
 
    return (double) value.integer;
2484
 
  case DECIMAL_VALUE:
2485
 
  {
2486
 
    double result;
2487
 
    my_decimal2double(E_DEC_FATAL_ERROR, &decimal_value, &result);
2488
 
    return result;
2489
 
  }
2490
 
  case STRING_VALUE:
2491
 
  case LONG_DATA_VALUE:
2492
 
  {
2493
 
    int dummy_err;
2494
 
    char *end_not_used;
2495
 
    return my_strntod(str_value.charset(), (char*) str_value.ptr(),
2496
 
                      str_value.length(), &end_not_used, &dummy_err);
2497
 
  }
2498
 
  case TIME_VALUE:
2499
 
    /*
2500
 
      This works for example when user says SELECT ?+0.0 and supplies
2501
 
      time value for the placeholder.
2502
 
    */
2503
 
    return uint64_t2double(TIME_to_uint64_t(&value.time));
2504
 
  case NULL_VALUE:
2505
 
    return 0.0;
2506
 
  default:
2507
 
    assert(0);
2508
 
  }
2509
 
  return 0.0;
2510
 
} 
2511
 
 
2512
 
 
2513
 
int64_t Item_param::val_int() 
2514
 
{ 
2515
 
  switch (state) {
2516
 
  case REAL_VALUE:
2517
 
    return (int64_t) rint(value.real);
2518
 
  case INT_VALUE:
2519
 
    return value.integer;
2520
 
  case DECIMAL_VALUE:
2521
 
  {
2522
 
    int64_t i;
2523
 
    my_decimal2int(E_DEC_FATAL_ERROR, &decimal_value, unsigned_flag, &i);
2524
 
    return i;
2525
 
  }
2526
 
  case STRING_VALUE:
2527
 
  case LONG_DATA_VALUE:
2528
 
    {
2529
 
      int dummy_err;
2530
 
      return my_strntoll(str_value.charset(), str_value.ptr(),
2531
 
                         str_value.length(), 10, (char**) 0, &dummy_err);
2532
 
    }
2533
 
  case TIME_VALUE:
2534
 
    return (int64_t) TIME_to_uint64_t(&value.time);
2535
 
  case NULL_VALUE:
2536
 
    return 0; 
2537
 
  default:
2538
 
    assert(0);
2539
 
  }
2540
 
  return 0;
2541
 
}
2542
 
 
2543
 
 
2544
 
my_decimal *Item_param::val_decimal(my_decimal *dec)
2545
 
{
2546
 
  switch (state) {
2547
 
  case DECIMAL_VALUE:
2548
 
    return &decimal_value;
2549
 
  case REAL_VALUE:
2550
 
    double2my_decimal(E_DEC_FATAL_ERROR, value.real, dec);
2551
 
    return dec;
2552
 
  case INT_VALUE:
2553
 
    int2my_decimal(E_DEC_FATAL_ERROR, value.integer, unsigned_flag, dec);
2554
 
    return dec;
2555
 
  case STRING_VALUE:
2556
 
  case LONG_DATA_VALUE:
2557
 
    string2my_decimal(E_DEC_FATAL_ERROR, &str_value, dec);
2558
 
    return dec;
2559
 
  case TIME_VALUE:
2560
 
  {
2561
 
    int64_t i= (int64_t) TIME_to_uint64_t(&value.time);
2562
 
    int2my_decimal(E_DEC_FATAL_ERROR, i, 0, dec);
2563
 
    return dec;
2564
 
  }
2565
 
  case NULL_VALUE:
2566
 
    return 0; 
2567
 
  default:
2568
 
    assert(0);
2569
 
  }
2570
 
  return 0;
2571
 
}
2572
 
 
2573
 
 
2574
 
String *Item_param::val_str(String* str) 
2575
 
{ 
2576
 
  switch (state) {
2577
 
  case STRING_VALUE:
2578
 
  case LONG_DATA_VALUE:
2579
 
    return &str_value_ptr;
2580
 
  case REAL_VALUE:
2581
 
    str->set_real(value.real, NOT_FIXED_DEC, &my_charset_bin);
2582
 
    return str;
2583
 
  case INT_VALUE:
2584
 
    str->set(value.integer, &my_charset_bin);
2585
 
    return str;
2586
 
  case DECIMAL_VALUE:
2587
 
    if (my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value,
2588
 
                          0, 0, 0, str) <= 1)
2589
 
      return str;
2590
 
    return NULL;
2591
 
  case TIME_VALUE:
2592
 
  {
2593
 
    if (str->reserve(MAX_DATE_STRING_REP_LENGTH))
2594
 
      break;
2595
 
    str->length((uint) my_TIME_to_str(&value.time, (char*) str->ptr()));
2596
 
    str->set_charset(&my_charset_bin);
2597
 
    return str;
2598
 
  }
2599
 
  case NULL_VALUE:
2600
 
    return NULL; 
2601
 
  default:
2602
 
    assert(0);
2603
 
  }
2604
 
  return str;
2605
 
}
2606
 
 
2607
 
/**
2608
 
  Return Param item values in string format, for generating the dynamic 
2609
 
  query used in update/binary logs.
2610
 
 
2611
 
  @todo
2612
 
    - Change interface and implementation to fill log data in place
2613
 
    and avoid one more memcpy/alloc between str and log string.
2614
 
    - In case of error we need to notify replication
2615
 
    that binary log contains wrong statement 
2616
 
*/
2617
 
 
2618
 
const String *Item_param::query_val_str(String* str) const
2619
 
{
2620
 
  switch (state) {
2621
 
  case INT_VALUE:
2622
 
    str->set_int(value.integer, unsigned_flag, &my_charset_bin);
2623
 
    break;
2624
 
  case REAL_VALUE:
2625
 
    str->set_real(value.real, NOT_FIXED_DEC, &my_charset_bin);
2626
 
    break;
2627
 
  case DECIMAL_VALUE:
2628
 
    if (my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value,
2629
 
                          0, 0, 0, str) > 1)
2630
 
      return &my_null_string;
2631
 
    break;
2632
 
  case TIME_VALUE:
2633
 
    {
2634
 
      char *buf, *ptr;
2635
 
      str->length(0);
2636
 
      /*
2637
 
        TODO: in case of error we need to notify replication
2638
 
        that binary log contains wrong statement 
2639
 
      */
2640
 
      if (str->reserve(MAX_DATE_STRING_REP_LENGTH+3))
2641
 
        break; 
2642
 
 
2643
 
      /* Create date string inplace */
2644
 
      buf= str->c_ptr_quick();
2645
 
      ptr= buf;
2646
 
      *ptr++= '\'';
2647
 
      ptr+= (uint) my_TIME_to_str(&value.time, ptr);
2648
 
      *ptr++= '\'';
2649
 
      str->length((uint32_t) (ptr - buf));
2650
 
      break;
2651
 
    }
2652
 
  case STRING_VALUE:
2653
 
  case LONG_DATA_VALUE:
2654
 
    {
2655
 
      str->length(0);
2656
 
      append_query_string(value.cs_info.character_set_client, &str_value, str);
2657
 
      break;
2658
 
    }
2659
 
  case NULL_VALUE:
2660
 
    return &my_null_string;
2661
 
  default:
2662
 
    assert(0);
2663
 
  }
2664
 
  return str;
2665
 
}
2666
 
 
2667
 
 
2668
 
/**
2669
 
  Convert string from client character set to the character set of
2670
 
  connection.
2671
 
*/
2672
 
 
2673
 
bool Item_param::convert_str_value(THD *thd)
2674
 
{
2675
 
  bool rc= false;
2676
 
  if (state == STRING_VALUE || state == LONG_DATA_VALUE)
2677
 
  {
2678
 
    /*
2679
 
      Check is so simple because all charsets were set up properly
2680
 
      in setup_one_conversion_function, where typecode of
2681
 
      placeholder was also taken into account: the variables are different
2682
 
      here only if conversion is really necessary.
2683
 
    */
2684
 
    if (value.cs_info.final_character_set_of_str_value !=
2685
 
        value.cs_info.character_set_of_placeholder)
2686
 
    {
2687
 
      rc= thd->convert_string(&str_value,
2688
 
                              value.cs_info.character_set_of_placeholder,
2689
 
                              value.cs_info.final_character_set_of_str_value);
2690
 
    }
2691
 
    else
2692
 
      str_value.set_charset(value.cs_info.final_character_set_of_str_value);
2693
 
    /* Here str_value is guaranteed to be in final_character_set_of_str_value */
2694
 
 
2695
 
    max_length= str_value.length();
2696
 
    decimals= 0;
2697
 
    /*
2698
 
      str_value_ptr is returned from val_str(). It must be not alloced
2699
 
      to prevent it's modification by val_str() invoker.
2700
 
    */
2701
 
    str_value_ptr.set(str_value.ptr(), str_value.length(),
2702
 
                      str_value.charset());
2703
 
    /* Synchronize item charset with value charset */
2704
 
    collation.set(str_value.charset(), DERIVATION_COERCIBLE);
2705
 
  }
2706
 
  return rc;
2707
 
}
2708
 
 
2709
 
 
2710
 
bool Item_param::basic_const_item() const
2711
 
{
2712
 
  if (state == NO_VALUE || state == TIME_VALUE)
2713
 
    return false;
2714
 
  return true;
2715
 
}
2716
 
 
2717
 
 
2718
 
Item *
2719
 
Item_param::clone_item()
2720
 
{
2721
 
  /* see comments in the header file */
2722
 
  switch (state) {
2723
 
  case NULL_VALUE:
2724
 
    return new Item_null(name);
2725
 
  case INT_VALUE:
2726
 
    return (unsigned_flag ?
2727
 
            new Item_uint(name, value.integer, max_length) :
2728
 
            new Item_int(name, value.integer, max_length));
2729
 
  case REAL_VALUE:
2730
 
    return new Item_float(name, value.real, decimals, max_length);
2731
 
  case STRING_VALUE:
2732
 
  case LONG_DATA_VALUE:
2733
 
    return new Item_string(name, str_value.c_ptr_quick(), str_value.length(),
2734
 
                           str_value.charset());
2735
 
  case TIME_VALUE:
2736
 
    break;
2737
 
  case NO_VALUE:
2738
 
  default:
2739
 
    assert(0);
2740
 
  };
2741
 
  return 0;
2742
 
}
2743
 
 
2744
 
 
2745
 
bool
2746
 
Item_param::eq(const Item *arg, bool binary_cmp) const
2747
 
{
2748
 
  Item *item;
2749
 
  if (!basic_const_item() || !arg->basic_const_item() || arg->type() != type())
2750
 
    return false;
2751
 
  /*
2752
 
    We need to cast off const to call val_int(). This should be OK for
2753
 
    a basic constant.
2754
 
  */
2755
 
  item= (Item*) arg;
2756
 
 
2757
 
  switch (state) {
2758
 
  case NULL_VALUE:
2759
 
    return true;
2760
 
  case INT_VALUE:
2761
 
    return value.integer == item->val_int() &&
2762
 
           unsigned_flag == item->unsigned_flag;
2763
 
  case REAL_VALUE:
2764
 
    return value.real == item->val_real();
2765
 
  case STRING_VALUE:
2766
 
  case LONG_DATA_VALUE:
2767
 
    if (binary_cmp)
2768
 
      return !stringcmp(&str_value, &item->str_value);
2769
 
    return !sortcmp(&str_value, &item->str_value, collation.collation);
2770
 
  default:
2771
 
    break;
2772
 
  }
2773
 
  return false;
2774
 
}
2775
 
 
2776
 
/* End of Item_param related */
2777
 
 
2778
 
void Item_param::print(String *str,
2779
 
                       enum_query_type query_type __attribute__((unused)))
2780
 
{
2781
 
  if (state == NO_VALUE)
2782
 
  {
2783
 
    str->append('?');
2784
 
  }
2785
 
  else
2786
 
  {
2787
 
    char buffer[STRING_BUFFER_USUAL_SIZE];
2788
 
    String tmp(buffer, sizeof(buffer), &my_charset_bin);
2789
 
    const String *res;
2790
 
    res= query_val_str(&tmp);
2791
 
    str->append(*res);
2792
 
  }
2793
 
}
2794
 
 
2795
 
 
2796
 
/****************************************************************************
2797
 
  Item_copy_string
2798
 
****************************************************************************/
2799
 
 
2800
 
void Item_copy_string::copy()
2801
 
{
2802
 
  String *res=item->val_str(&str_value);
2803
 
  if (res && res != &str_value)
2804
 
    str_value.copy(*res);
2805
 
  null_value=item->null_value;
2806
 
}
2807
 
 
2808
 
/* ARGSUSED */
2809
 
String *Item_copy_string::val_str(String *str __attribute__((unused)))
2810
 
{
2811
 
  // Item_copy_string is used without fix_fields call
2812
 
  if (null_value)
2813
 
    return (String*) 0;
2814
 
  return &str_value;
2815
 
}
2816
 
 
2817
 
 
2818
 
my_decimal *Item_copy_string::val_decimal(my_decimal *decimal_value)
2819
 
{
2820
 
  // Item_copy_string is used without fix_fields call
2821
 
  if (null_value)
2822
 
    return 0;
2823
 
  string2my_decimal(E_DEC_FATAL_ERROR, &str_value, decimal_value);
2824
 
  return (decimal_value);
2825
 
}
2826
 
 
 
770
    session->change_item_tree(ref, item_ref);
 
771
  }
 
772
}
2827
773
 
2828
774
/*
2829
775
  Functions to convert item to field (for send_fields)
2830
776
*/
2831
 
 
2832
 
/* ARGSUSED */
2833
 
bool Item::fix_fields(THD *thd __attribute__((unused)),
2834
 
                      Item **ref __attribute__((unused)))
 
777
bool Item::fix_fields(Session *, Item **)
2835
778
{
2836
 
 
2837
 
  // We do not check fields which are fixed during construction
2838
 
  assert(fixed == 0 || basic_const_item());
2839
 
  fixed= 1;
 
779
  /* We do not check fields which are fixed during construction */
 
780
  assert(! fixed || basic_const_item());
 
781
  fixed= true;
2840
782
  return false;
2841
783
}
2842
784
 
2843
 
double Item_ref_null_helper::val_real()
2844
 
{
2845
 
  assert(fixed == 1);
2846
 
  double tmp= (*ref)->val_result();
2847
 
  owner->was_null|= null_value= (*ref)->null_value;
2848
 
  return tmp;
2849
 
}
2850
 
 
2851
 
 
2852
 
int64_t Item_ref_null_helper::val_int()
2853
 
{
2854
 
  assert(fixed == 1);
2855
 
  int64_t tmp= (*ref)->val_int_result();
2856
 
  owner->was_null|= null_value= (*ref)->null_value;
2857
 
  return tmp;
2858
 
}
2859
 
 
2860
 
 
2861
 
my_decimal *Item_ref_null_helper::val_decimal(my_decimal *decimal_value)
2862
 
{
2863
 
  assert(fixed == 1);
2864
 
  my_decimal *val= (*ref)->val_decimal_result(decimal_value);
2865
 
  owner->was_null|= null_value= (*ref)->null_value;
2866
 
  return val;
2867
 
}
2868
 
 
2869
 
 
2870
 
bool Item_ref_null_helper::val_bool()
2871
 
{
2872
 
  assert(fixed == 1);
2873
 
  bool val= (*ref)->val_bool_result();
2874
 
  owner->was_null|= null_value= (*ref)->null_value;
2875
 
  return val;
2876
 
}
2877
 
 
2878
 
 
2879
 
String* Item_ref_null_helper::val_str(String* s)
2880
 
{
2881
 
  assert(fixed == 1);
2882
 
  String* tmp= (*ref)->str_result(s);
2883
 
  owner->was_null|= null_value= (*ref)->null_value;
2884
 
  return tmp;
2885
 
}
2886
 
 
2887
 
 
2888
 
bool Item_ref_null_helper::get_date(DRIZZLE_TIME *ltime, uint fuzzydate)
2889
 
{  
2890
 
  return (owner->was_null|= null_value= (*ref)->get_date(ltime, fuzzydate));
2891
 
}
2892
 
 
2893
 
 
2894
 
/**
2895
 
  Mark item and SELECT_LEXs as dependent if item was resolved in
2896
 
  outer SELECT.
2897
 
 
2898
 
  @param thd             thread handler
2899
 
  @param last            select from which current item depend
2900
 
  @param current         current select
2901
 
  @param resolved_item   item which was resolved in outer SELECT(for warning)
2902
 
  @param mark_item       item which should be marked (can be differ in case of
2903
 
                         substitution)
2904
 
*/
2905
 
 
2906
 
static void mark_as_dependent(THD *thd, SELECT_LEX *last, SELECT_LEX *current,
 
785
void mark_as_dependent(Session *session, Select_Lex *last, Select_Lex *current,
2907
786
                              Item_ident *resolved_item,
2908
787
                              Item_ident *mark_item)
2909
788
{
2911
790
                        resolved_item->db_name : "");
2912
791
  const char *table_name= (resolved_item->table_name ?
2913
792
                           resolved_item->table_name : "");
2914
 
  /* store pointer on SELECT_LEX from which item is dependent */
 
793
  /* store pointer on Select_Lex from which item is dependent */
2915
794
  if (mark_item)
2916
795
    mark_item->depended_from= last;
2917
796
  current->mark_as_dependent(last);
2918
 
  if (thd->lex->describe & DESCRIBE_EXTENDED)
 
797
  if (session->lex->describe & DESCRIBE_EXTENDED)
2919
798
  {
2920
799
    char warn_buff[DRIZZLE_ERRMSG_SIZE];
2921
800
    sprintf(warn_buff, ER(ER_WARN_FIELD_RESOLVED),
2923
802
            table_name, (table_name [0] ? "." : ""),
2924
803
            resolved_item->field_name,
2925
804
            current->select_number, last->select_number);
2926
 
    push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
805
    push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
2927
806
                 ER_WARN_FIELD_RESOLVED, warn_buff);
2928
807
  }
2929
808
}
2930
809
 
2931
 
 
2932
 
/**
2933
 
  Mark range of selects and resolved identifier (field/reference)
2934
 
  item as dependent.
2935
 
 
2936
 
  @param thd             thread handler
2937
 
  @param last_select     select where resolved_item was resolved
2938
 
  @param current_sel     current select (select where resolved_item was placed)
2939
 
  @param found_field     field which was found during resolving
2940
 
  @param found_item      Item which was found during resolving (if resolved
2941
 
                         identifier belongs to VIEW)
2942
 
  @param resolved_item   Identifier which was resolved
2943
 
 
2944
 
  @note
2945
 
    We have to mark all items between current_sel (including) and
2946
 
    last_select (excluding) as dependend (select before last_select should
2947
 
    be marked with actual table mask used by resolved item, all other with
2948
 
    OUTER_REF_TABLE_BIT) and also write dependence information to Item of
2949
 
    resolved identifier.
2950
 
*/
2951
 
 
2952
 
void mark_select_range_as_dependent(THD *thd,
2953
 
                                    SELECT_LEX *last_select,
2954
 
                                    SELECT_LEX *current_sel,
 
810
void mark_select_range_as_dependent(Session *session,
 
811
                                    Select_Lex *last_select,
 
812
                                    Select_Lex *current_sel,
2955
813
                                    Field *found_field, Item *found_item,
2956
814
                                    Item_ident *resolved_item)
2957
815
{
2961
819
    done once when we resolved this field and cached result of
2962
820
    resolving)
2963
821
  */
2964
 
  SELECT_LEX *previous_select= current_sel;
 
822
  Select_Lex *previous_select= current_sel;
2965
823
  for (; previous_select->outer_select() != last_select;
2966
824
       previous_select= previous_select->outer_select())
2967
825
  {
2968
 
    Item_subselect *prev_subselect_item=
2969
 
      previous_select->master_unit()->item;
 
826
    Item_subselect *prev_subselect_item= previous_select->master_unit()->item;
2970
827
    prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
2971
828
    prev_subselect_item->const_item_cache= 0;
2972
829
  }
2973
830
  {
2974
 
    Item_subselect *prev_subselect_item=
2975
 
      previous_select->master_unit()->item;
 
831
    Item_subselect *prev_subselect_item= previous_select->master_unit()->item;
2976
832
    Item_ident *dependent= resolved_item;
2977
833
    if (found_field == view_ref_found)
2978
834
    {
2979
835
      Item::Type type= found_item->type();
2980
 
      prev_subselect_item->used_tables_cache|=
2981
 
        found_item->used_tables();
 
836
      prev_subselect_item->used_tables_cache|= found_item->used_tables();
2982
837
      dependent= ((type == Item::REF_ITEM || type == Item::FIELD_ITEM) ?
2983
838
                  (Item_ident*) found_item :
2984
839
                  0);
2985
840
    }
2986
841
    else
2987
 
      prev_subselect_item->used_tables_cache|=
2988
 
        found_field->table->map;
 
842
      prev_subselect_item->used_tables_cache|= found_field->table->map;
2989
843
    prev_subselect_item->const_item_cache= 0;
2990
 
    mark_as_dependent(thd, last_select, current_sel, resolved_item,
 
844
    mark_as_dependent(session, last_select, current_sel, resolved_item,
2991
845
                      dependent);
2992
846
  }
2993
847
}
2994
848
 
2995
 
 
2996
849
/**
2997
850
  Search a GROUP BY clause for a field with a certain name.
2998
851
 
3007
860
    - the found item on success
3008
861
    - NULL if find_item is not in group_list
3009
862
*/
3010
 
 
3011
 
static Item** find_field_in_group_list(Item *find_item, ORDER *group_list)
 
863
static Item** find_field_in_group_list(Item *find_item, order_st *group_list)
3012
864
{
3013
865
  const char *db_name;
3014
866
  const char *table_name;
3015
867
  const char *field_name;
3016
 
  ORDER      *found_group= NULL;
3017
 
  int         found_match_degree= 0;
 
868
  order_st *found_group= NULL;
 
869
  int found_match_degree= 0;
3018
870
  Item_ident *cur_field;
3019
 
  int         cur_match_degree= 0;
3020
 
  char        name_buff[NAME_LEN+1];
 
871
  int cur_match_degree= 0;
 
872
  char name_buff[NAME_LEN+1];
3021
873
 
3022
874
  if (find_item->type() == Item::FIELD_ITEM ||
3023
875
      find_item->type() == Item::REF_ITEM)
3024
876
  {
3025
 
    db_name=    ((Item_ident*) find_item)->db_name;
 
877
    db_name= ((Item_ident*) find_item)->db_name;
3026
878
    table_name= ((Item_ident*) find_item)->table_name;
3027
879
    field_name= ((Item_ident*) find_item)->field_name;
3028
880
  }
3029
881
  else
3030
882
    return NULL;
3031
883
 
3032
 
  if (db_name && lower_case_table_names)
 
884
  if (db_name)
3033
885
  {
3034
886
    /* Convert database to lower case for comparison */
3035
 
    strmake(name_buff, db_name, sizeof(name_buff)-1);
 
887
    strncpy(name_buff, db_name, sizeof(name_buff)-1);
3036
888
    my_casedn_str(files_charset_info, name_buff);
3037
889
    db_name= name_buff;
3038
890
  }
3039
891
 
3040
892
  assert(field_name != 0);
3041
893
 
3042
 
  for (ORDER *cur_group= group_list ; cur_group ; cur_group= cur_group->next)
 
894
  for (order_st *cur_group= group_list ; cur_group ; cur_group= cur_group->next)
3043
895
  {
3044
896
    if ((*(cur_group->item))->real_item()->type() == Item::FIELD_ITEM)
3045
897
    {
3046
898
      cur_field= (Item_ident*) *cur_group->item;
3047
899
      cur_match_degree= 0;
3048
 
      
 
900
 
3049
901
      assert(cur_field->field_name != 0);
3050
902
 
3051
 
      if (!my_strcasecmp(system_charset_info,
3052
 
                         cur_field->field_name, field_name))
 
903
      if (! my_strcasecmp(system_charset_info, cur_field->field_name, field_name))
3053
904
        ++cur_match_degree;
3054
905
      else
3055
906
        continue;
3077
928
        found_match_degree= cur_match_degree;
3078
929
        found_group= cur_group;
3079
930
      }
3080
 
      else if (found_group && (cur_match_degree == found_match_degree) &&
 
931
      else if (found_group &&
 
932
               (cur_match_degree == found_match_degree) &&
3081
933
               ! (*(found_group->item))->eq(cur_field, 0))
3082
934
      {
3083
935
        /*
3085
937
          best match, they must reference the same column, otherwise the field
3086
938
          is ambiguous.
3087
939
        */
3088
 
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
3089
 
                 find_item->full_name(), current_thd->where);
 
940
        my_error(ER_NON_UNIQ_ERROR, MYF(0), find_item->full_name(), current_session->where);
3090
941
        return NULL;
3091
942
      }
3092
943
    }
3098
949
    return NULL;
3099
950
}
3100
951
 
3101
 
 
3102
 
/**
3103
 
  Resolve a column reference in a sub-select.
3104
 
 
3105
 
  Resolve a column reference (usually inside a HAVING clause) against the
3106
 
  SELECT and GROUP BY clauses of the query described by 'select'. The name
3107
 
  resolution algorithm searches both the SELECT and GROUP BY clauses, and in
3108
 
  case of a name conflict prefers GROUP BY column names over SELECT names. If
3109
 
  both clauses contain different fields with the same names, a warning is
3110
 
  issued that name of 'ref' is ambiguous. We extend ANSI SQL in that when no
3111
 
  GROUP BY column is found, then a HAVING name is resolved as a possibly
3112
 
  derived SELECT column. This extension is allowed only if the
3113
 
  MODE_ONLY_FULL_GROUP_BY sql mode isn't enabled.
3114
 
 
3115
 
  @param thd     current thread
3116
 
  @param ref     column reference being resolved
3117
 
  @param select  the select that ref is resolved against
3118
 
 
3119
 
  @note
3120
 
    The resolution procedure is:
3121
 
    - Search for a column or derived column named col_ref_i [in table T_j]
3122
 
    in the SELECT clause of Q.
3123
 
    - Search for a column named col_ref_i [in table T_j]
3124
 
    in the GROUP BY clause of Q.
3125
 
    - If found different columns with the same name in GROUP BY and SELECT
3126
 
    - issue a warning and return the GROUP BY column,
3127
 
    - otherwise
3128
 
    - if the MODE_ONLY_FULL_GROUP_BY mode is enabled return error
3129
 
    - else return the found SELECT column.
3130
 
 
3131
 
 
3132
 
  @return
3133
 
    - NULL - there was an error, and the error was already reported
3134
 
    - not_found_item - the item was not resolved, no error was reported
3135
 
    - resolved item - if the item was resolved
3136
 
*/
3137
 
 
3138
 
static Item**
3139
 
resolve_ref_in_select_and_group(THD *thd, Item_ident *ref, SELECT_LEX *select)
 
952
Item** resolve_ref_in_select_and_group(Session *session, Item_ident *ref, Select_Lex *select)
3140
953
{
3141
954
  Item **group_by_ref= NULL;
3142
955
  Item **select_ref= NULL;
3143
 
  ORDER *group_list= (ORDER*) select->group_list.first;
 
956
  order_st *group_list= (order_st*) select->group_list.first;
3144
957
  bool ambiguous_fields= false;
3145
 
  uint counter;
 
958
  uint32_t counter;
3146
959
  enum_resolution_type resolution;
3147
960
 
3148
961
  /*
3160
973
  if (select->having_fix_field && !ref->with_sum_func && group_list)
3161
974
  {
3162
975
    group_by_ref= find_field_in_group_list(ref, group_list);
3163
 
    
 
976
 
3164
977
    /* Check if the fields found in SELECT and GROUP BY are the same field. */
3165
978
    if (group_by_ref && (select_ref != not_found_item) &&
3166
979
        !((*group_by_ref)->eq(*select_ref, 0)))
3167
980
    {
3168
981
      ambiguous_fields= true;
3169
 
      push_warning_printf(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_NON_UNIQ_ERROR,
 
982
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_NON_UNIQ_ERROR,
3170
983
                          ER(ER_NON_UNIQ_ERROR), ref->full_name(),
3171
 
                          current_thd->where);
 
984
                          current_session->where);
3172
985
 
3173
986
    }
3174
987
  }
3196
1009
  return (Item**) not_found_item;
3197
1010
}
3198
1011
 
3199
 
 
3200
 
/**
3201
 
  Resolve the name of an outer select column reference.
3202
 
 
3203
 
  The method resolves the column reference represented by 'this' as a column
3204
 
  present in outer selects that contain current select.
3205
 
 
3206
 
  In prepared statements, because of cache, find_field_in_tables()
3207
 
  can resolve fields even if they don't belong to current context.
3208
 
  In this case this method only finds appropriate context and marks
3209
 
  current select as dependent. The found reference of field should be
3210
 
  provided in 'from_field'.
3211
 
 
3212
 
  @param[in] thd             current thread
3213
 
  @param[in,out] from_field  found field reference or (Field*)not_found_field
3214
 
  @param[in,out] reference   view column if this item was resolved to a
3215
 
    view column
3216
 
 
3217
 
  @note
3218
 
    This is the inner loop of Item_field::fix_fields:
3219
 
  @code
3220
 
        for each outer query Q_k beginning from the inner-most one
3221
 
        {
3222
 
          search for a column or derived column named col_ref_i
3223
 
          [in table T_j] in the FROM clause of Q_k;
3224
 
 
3225
 
          if such a column is not found
3226
 
            Search for a column or derived column named col_ref_i
3227
 
            [in table T_j] in the SELECT and GROUP clauses of Q_k.
3228
 
        }
3229
 
  @endcode
3230
 
 
3231
 
  @retval
3232
 
    1   column succefully resolved and fix_fields() should continue.
3233
 
  @retval
3234
 
    0   column fully fixed and fix_fields() should return false
3235
 
  @retval
3236
 
    -1  error occured
3237
 
*/
3238
 
 
3239
 
int
3240
 
Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
3241
 
{
3242
 
  enum_parsing_place place= NO_MATTER;
3243
 
  bool field_found= (*from_field != not_found_field);
3244
 
  bool upward_lookup= false;
3245
 
 
3246
 
  /*
3247
 
    If there are outer contexts (outer selects, but current select is
3248
 
    not derived table or view) try to resolve this reference in the
3249
 
    outer contexts.
3250
 
 
3251
 
    We treat each subselect as a separate namespace, so that different
3252
 
    subselects may contain columns with the same names. The subselects
3253
 
    are searched starting from the innermost.
3254
 
  */
3255
 
  Name_resolution_context *last_checked_context= context;
3256
 
  Item **ref= (Item **) not_found_item;
3257
 
  SELECT_LEX *current_sel= (SELECT_LEX *) thd->lex->current_select;
3258
 
  Name_resolution_context *outer_context= 0;
3259
 
  SELECT_LEX *select= 0;
3260
 
  /* Currently derived tables cannot be correlated */
3261
 
  if (current_sel->master_unit()->first_select()->linkage !=
3262
 
      DERIVED_TABLE_TYPE)
3263
 
    outer_context= context->outer_context;
3264
 
  for (;
3265
 
       outer_context;
3266
 
       outer_context= outer_context->outer_context)
3267
 
  {
3268
 
    select= outer_context->select_lex;
3269
 
    Item_subselect *prev_subselect_item=
3270
 
      last_checked_context->select_lex->master_unit()->item;
3271
 
    last_checked_context= outer_context;
3272
 
    upward_lookup= true;
3273
 
 
3274
 
    place= prev_subselect_item->parsing_place;
3275
 
    /*
3276
 
      If outer_field is set, field was already found by first call
3277
 
      to find_field_in_tables(). Only need to find appropriate context.
3278
 
    */
3279
 
    if (field_found && outer_context->select_lex !=
3280
 
        cached_table->select_lex)
3281
 
      continue;
3282
 
    /*
3283
 
      In case of a view, find_field_in_tables() writes the pointer to
3284
 
      the found view field into '*reference', in other words, it
3285
 
      substitutes this Item_field with the found expression.
3286
 
    */
3287
 
    if (field_found || (*from_field= find_field_in_tables(thd, this,
3288
 
                                          outer_context->
3289
 
                                            first_name_resolution_table,
3290
 
                                          outer_context->
3291
 
                                            last_name_resolution_table,
3292
 
                                          reference,
3293
 
                                          IGNORE_EXCEPT_NON_UNIQUE,
3294
 
                                          true, true)) !=
3295
 
        not_found_field)
3296
 
    {
3297
 
      if (*from_field)
3298
 
      {
3299
 
        if (*from_field != view_ref_found)
3300
 
        {
3301
 
          prev_subselect_item->used_tables_cache|= (*from_field)->table->map;
3302
 
          prev_subselect_item->const_item_cache= 0;
3303
 
          set_field(*from_field);
3304
 
          if (!last_checked_context->select_lex->having_fix_field &&
3305
 
              select->group_list.elements &&
3306
 
              (place == SELECT_LIST || place == IN_HAVING))
3307
 
          {
3308
 
            Item_outer_ref *rf;
3309
 
            /*
3310
 
              If an outer field is resolved in a grouping select then it
3311
 
              is replaced for an Item_outer_ref object. Otherwise an
3312
 
              Item_field object is used.
3313
 
              The new Item_outer_ref object is saved in the inner_refs_list of
3314
 
              the outer select. Here it is only created. It can be fixed only
3315
 
              after the original field has been fixed and this is done in the
3316
 
              fix_inner_refs() function.
3317
 
            */
3318
 
            ;
3319
 
            if (!(rf= new Item_outer_ref(context, this)))
3320
 
              return -1;
3321
 
            thd->change_item_tree(reference, rf);
3322
 
            select->inner_refs_list.push_back(rf);
3323
 
            rf->in_sum_func= thd->lex->in_sum_func;
3324
 
          }
3325
 
          /*
3326
 
            A reference is resolved to a nest level that's outer or the same as
3327
 
            the nest level of the enclosing set function : adjust the value of
3328
 
            max_arg_level for the function if it's needed.
3329
 
          */
3330
 
          if (thd->lex->in_sum_func &&
3331
 
              thd->lex->in_sum_func->nest_level >= select->nest_level)
3332
 
          {
3333
 
            Item::Type ref_type= (*reference)->type();
3334
 
            set_if_bigger(thd->lex->in_sum_func->max_arg_level,
3335
 
                          select->nest_level);
3336
 
            set_field(*from_field);
3337
 
            fixed= 1;
3338
 
            mark_as_dependent(thd, last_checked_context->select_lex,
3339
 
                              context->select_lex, this,
3340
 
                              ((ref_type == REF_ITEM ||
3341
 
                                ref_type == FIELD_ITEM) ?
3342
 
                               (Item_ident*) (*reference) : 0));
3343
 
            return 0;
3344
 
          }
3345
 
        }
3346
 
        else
3347
 
        {
3348
 
          Item::Type ref_type= (*reference)->type();
3349
 
          prev_subselect_item->used_tables_cache|=
3350
 
            (*reference)->used_tables();
3351
 
          prev_subselect_item->const_item_cache&=
3352
 
            (*reference)->const_item();
3353
 
          mark_as_dependent(thd, last_checked_context->select_lex,
3354
 
                            context->select_lex, this,
3355
 
                            ((ref_type == REF_ITEM || ref_type == FIELD_ITEM) ?
3356
 
                             (Item_ident*) (*reference) :
3357
 
                             0));
3358
 
          /*
3359
 
            A reference to a view field had been found and we
3360
 
            substituted it instead of this Item (find_field_in_tables
3361
 
            does it by assigning the new value to *reference), so now
3362
 
            we can return from this function.
3363
 
          */
3364
 
          return 0;
3365
 
        }
3366
 
      }
3367
 
      break;
3368
 
    }
3369
 
 
3370
 
    /* Search in SELECT and GROUP lists of the outer select. */
3371
 
    if (place != IN_WHERE && place != IN_ON)
3372
 
    {
3373
 
      if (!(ref= resolve_ref_in_select_and_group(thd, this, select)))
3374
 
        return -1; /* Some error occurred (e.g. ambiguous names). */
3375
 
      if (ref != not_found_item)
3376
 
      {
3377
 
        assert(*ref && (*ref)->fixed);
3378
 
        prev_subselect_item->used_tables_cache|= (*ref)->used_tables();
3379
 
        prev_subselect_item->const_item_cache&= (*ref)->const_item();
3380
 
        break;
3381
 
      }
3382
 
    }
3383
 
 
3384
 
    /*
3385
 
      Reference is not found in this select => this subquery depend on
3386
 
      outer select (or we just trying to find wrong identifier, in this
3387
 
      case it does not matter which used tables bits we set)
3388
 
    */
3389
 
    prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
3390
 
    prev_subselect_item->const_item_cache= 0;
3391
 
  }
3392
 
 
3393
 
  assert(ref != 0);
3394
 
  if (!*from_field)
3395
 
    return -1;
3396
 
  if (ref == not_found_item && *from_field == not_found_field)
3397
 
  {
3398
 
    if (upward_lookup)
3399
 
    {
3400
 
      // We can't say exactly what absent table or field
3401
 
      my_error(ER_BAD_FIELD_ERROR, MYF(0), full_name(), thd->where);
3402
 
    }
3403
 
    else
3404
 
    {
3405
 
      /* Call find_field_in_tables only to report the error */
3406
 
      find_field_in_tables(thd, this,
3407
 
                           context->first_name_resolution_table,
3408
 
                           context->last_name_resolution_table,
3409
 
                           reference, REPORT_ALL_ERRORS,
3410
 
                           !any_privileges &&
3411
 
                           true, true);
3412
 
    }
3413
 
    return -1;
3414
 
  }
3415
 
  else if (ref != not_found_item)
3416
 
  {
3417
 
    Item *save;
3418
 
    Item_ref *rf;
3419
 
 
3420
 
    /* Should have been checked in resolve_ref_in_select_and_group(). */
3421
 
    assert(*ref && (*ref)->fixed);
3422
 
    /*
3423
 
      Here, a subset of actions performed by Item_ref::set_properties
3424
 
      is not enough. So we pass ptr to NULL into Item_[direct]_ref
3425
 
      constructor, so no initialization is performed, and call 
3426
 
      fix_fields() below.
3427
 
    */
3428
 
    save= *ref;
3429
 
    *ref= NULL;                             // Don't call set_properties()
3430
 
    rf= (place == IN_HAVING ?
3431
 
         new Item_ref(context, ref, (char*) table_name,
3432
 
                      (char*) field_name, alias_name_used) :
3433
 
         (!select->group_list.elements ?
3434
 
         new Item_direct_ref(context, ref, (char*) table_name,
3435
 
                             (char*) field_name, alias_name_used) :
3436
 
         new Item_outer_ref(context, ref, (char*) table_name,
3437
 
                            (char*) field_name, alias_name_used)));
3438
 
    *ref= save;
3439
 
    if (!rf)
3440
 
      return -1;
3441
 
 
3442
 
    if (place != IN_HAVING && select->group_list.elements)
3443
 
    {
3444
 
      outer_context->select_lex->inner_refs_list.push_back((Item_outer_ref*)rf);
3445
 
      ((Item_outer_ref*)rf)->in_sum_func= thd->lex->in_sum_func;
3446
 
    }
3447
 
    thd->change_item_tree(reference, rf);
3448
 
    /*
3449
 
      rf is Item_ref => never substitute other items (in this case)
3450
 
      during fix_fields() => we can use rf after fix_fields()
3451
 
    */
3452
 
    assert(!rf->fixed);                // Assured by Item_ref()
3453
 
    if (rf->fix_fields(thd, reference) || rf->check_cols(1))
3454
 
      return -1;
3455
 
 
3456
 
    mark_as_dependent(thd, last_checked_context->select_lex,
3457
 
                      context->select_lex, this,
3458
 
                      rf);
3459
 
    return 0;
3460
 
  }
3461
 
  else
3462
 
  {
3463
 
    mark_as_dependent(thd, last_checked_context->select_lex,
3464
 
                      context->select_lex,
3465
 
                      this, (Item_ident*)*reference);
3466
 
    if (last_checked_context->select_lex->having_fix_field)
3467
 
    {
3468
 
      Item_ref *rf;
3469
 
      rf= new Item_ref(context,
3470
 
                       (cached_table->db[0] ? cached_table->db : 0),
3471
 
                       (char*) cached_table->alias, (char*) field_name);
3472
 
      if (!rf)
3473
 
        return -1;
3474
 
      thd->change_item_tree(reference, rf);
3475
 
      /*
3476
 
        rf is Item_ref => never substitute other items (in this case)
3477
 
        during fix_fields() => we can use rf after fix_fields()
3478
 
      */
3479
 
      assert(!rf->fixed);                // Assured by Item_ref()
3480
 
      if (rf->fix_fields(thd, reference) || rf->check_cols(1))
3481
 
        return -1;
3482
 
      return 0;
3483
 
    }
3484
 
  }
3485
 
  return 1;
3486
 
}
3487
 
 
3488
 
 
3489
 
/**
3490
 
  Resolve the name of a column reference.
3491
 
 
3492
 
  The method resolves the column reference represented by 'this' as a column
3493
 
  present in one of: FROM clause, SELECT clause, GROUP BY clause of a query
3494
 
  Q, or in outer queries that contain Q.
3495
 
 
3496
 
  The name resolution algorithm used is (where [T_j] is an optional table
3497
 
  name that qualifies the column name):
3498
 
 
3499
 
  @code
3500
 
    resolve_column_reference([T_j].col_ref_i)
3501
 
    {
3502
 
      search for a column or derived column named col_ref_i
3503
 
      [in table T_j] in the FROM clause of Q;
3504
 
 
3505
 
      if such a column is NOT found AND    // Lookup in outer queries.
3506
 
         there are outer queries
3507
 
      {
3508
 
        for each outer query Q_k beginning from the inner-most one
3509
 
        {
3510
 
          search for a column or derived column named col_ref_i
3511
 
          [in table T_j] in the FROM clause of Q_k;
3512
 
 
3513
 
          if such a column is not found
3514
 
            Search for a column or derived column named col_ref_i
3515
 
            [in table T_j] in the SELECT and GROUP clauses of Q_k.
3516
 
        }
3517
 
      }
3518
 
    }
3519
 
  @endcode
3520
 
 
3521
 
    Notice that compared to Item_ref::fix_fields, here we first search the FROM
3522
 
    clause, and then we search the SELECT and GROUP BY clauses.
3523
 
 
3524
 
  @param[in]     thd        current thread
3525
 
  @param[in,out] reference  view column if this item was resolved to a
3526
 
    view column
3527
 
 
3528
 
  @retval
3529
 
    true  if error
3530
 
  @retval
3531
 
    false on success
3532
 
*/
3533
 
 
3534
 
bool Item_field::fix_fields(THD *thd, Item **reference)
3535
 
{
3536
 
  assert(fixed == 0);
3537
 
  Field *from_field= (Field *)not_found_field;
3538
 
  bool outer_fixed= false;
3539
 
 
3540
 
  if (!field)                                   // If field is not checked
3541
 
  {
3542
 
    /*
3543
 
      In case of view, find_field_in_tables() write pointer to view field
3544
 
      expression to 'reference', i.e. it substitute that expression instead
3545
 
      of this Item_field
3546
 
    */
3547
 
    if ((from_field= find_field_in_tables(thd, this,
3548
 
                                          context->first_name_resolution_table,
3549
 
                                          context->last_name_resolution_table,
3550
 
                                          reference,
3551
 
                                          thd->lex->use_only_table_context ?
3552
 
                                            REPORT_ALL_ERRORS : 
3553
 
                                            IGNORE_EXCEPT_NON_UNIQUE,
3554
 
                                          !any_privileges,
3555
 
                                          true)) ==
3556
 
        not_found_field)
3557
 
    {
3558
 
      int ret;
3559
 
      /* Look up in current select's item_list to find aliased fields */
3560
 
      if (thd->lex->current_select->is_item_list_lookup)
3561
 
      {
3562
 
        uint counter;
3563
 
        enum_resolution_type resolution;
3564
 
        Item** res= find_item_in_list(this, thd->lex->current_select->item_list,
3565
 
                                      &counter, REPORT_EXCEPT_NOT_FOUND,
3566
 
                                      &resolution);
3567
 
        if (!res)
3568
 
          return 1;
3569
 
        if (resolution == RESOLVED_AGAINST_ALIAS)
3570
 
          alias_name_used= true;
3571
 
        if (res != (Item **)not_found_item)
3572
 
        {
3573
 
          if ((*res)->type() == Item::FIELD_ITEM)
3574
 
          {
3575
 
            /*
3576
 
              It's an Item_field referencing another Item_field in the select
3577
 
              list.
3578
 
              Use the field from the Item_field in the select list and leave
3579
 
              the Item_field instance in place.
3580
 
            */
3581
 
 
3582
 
            Field *new_field= (*((Item_field**)res))->field;
3583
 
 
3584
 
            if (new_field == NULL)
3585
 
            {
3586
 
              /* The column to which we link isn't valid. */
3587
 
              my_error(ER_BAD_FIELD_ERROR, MYF(0), (*res)->name, 
3588
 
                       current_thd->where);
3589
 
              return(1);
3590
 
            }
3591
 
 
3592
 
            set_field(new_field);
3593
 
            return 0;
3594
 
          }
3595
 
          else
3596
 
          {
3597
 
            /*
3598
 
              It's not an Item_field in the select list so we must make a new
3599
 
              Item_ref to point to the Item in the select list and replace the
3600
 
              Item_field created by the parser with the new Item_ref.
3601
 
            */
3602
 
            Item_ref *rf= new Item_ref(context, db_name,table_name,field_name);
3603
 
            if (!rf)
3604
 
              return 1;
3605
 
            thd->change_item_tree(reference, rf);
3606
 
            /*
3607
 
              Because Item_ref never substitutes itself with other items 
3608
 
              in Item_ref::fix_fields(), we can safely use the original 
3609
 
              pointer to it even after fix_fields()
3610
 
             */
3611
 
            return rf->fix_fields(thd, reference) ||  rf->check_cols(1);
3612
 
          }
3613
 
        }
3614
 
      }
3615
 
      if ((ret= fix_outer_field(thd, &from_field, reference)) < 0)
3616
 
        goto error;
3617
 
      outer_fixed= true;
3618
 
      if (!ret)
3619
 
        goto mark_non_agg_field;
3620
 
    }
3621
 
    else if (!from_field)
3622
 
      goto error;
3623
 
 
3624
 
    if (!outer_fixed && cached_table && cached_table->select_lex &&
3625
 
        context->select_lex &&
3626
 
        cached_table->select_lex != context->select_lex)
3627
 
    {
3628
 
      int ret;
3629
 
      if ((ret= fix_outer_field(thd, &from_field, reference)) < 0)
3630
 
        goto error;
3631
 
      outer_fixed= 1;
3632
 
      if (!ret)
3633
 
        goto mark_non_agg_field;
3634
 
    }
3635
 
 
3636
 
    /*
3637
 
      if it is not expression from merged VIEW we will set this field.
3638
 
 
3639
 
      We can leave expression substituted from view for next PS/SP rexecution
3640
 
      (i.e. do not register this substitution for reverting on cleanup()
3641
 
      (register_item_tree_changing())), because this subtree will be
3642
 
      fix_field'ed during setup_tables()->setup_underlying() (i.e. before
3643
 
      all other expressions of query, and references on tables which do
3644
 
      not present in query will not make problems.
3645
 
 
3646
 
      Also we suppose that view can't be changed during PS/SP life.
3647
 
    */
3648
 
    if (from_field == view_ref_found)
3649
 
      return false;
3650
 
 
3651
 
    set_field(from_field);
3652
 
    if (thd->lex->in_sum_func &&
3653
 
        thd->lex->in_sum_func->nest_level == 
3654
 
        thd->lex->current_select->nest_level)
3655
 
      set_if_bigger(thd->lex->in_sum_func->max_arg_level,
3656
 
                    thd->lex->current_select->nest_level);
3657
 
  }
3658
 
  else if (thd->mark_used_columns != MARK_COLUMNS_NONE)
3659
 
  {
3660
 
    TABLE *table= field->table;
3661
 
    MY_BITMAP *current_bitmap, *other_bitmap;
3662
 
    if (thd->mark_used_columns == MARK_COLUMNS_READ)
3663
 
    {
3664
 
      current_bitmap= table->read_set;
3665
 
      other_bitmap=   table->write_set;
3666
 
    }
3667
 
    else
3668
 
    {
3669
 
      current_bitmap= table->write_set;
3670
 
      other_bitmap=   table->read_set;
3671
 
    }
3672
 
    if (!bitmap_fast_test_and_set(current_bitmap, field->field_index))
3673
 
    {
3674
 
      if (!bitmap_is_set(other_bitmap, field->field_index))
3675
 
      {
3676
 
        /* First usage of column */
3677
 
        table->used_fields++;                     // Used to optimize loops
3678
 
        /* purecov: begin inspected */
3679
 
        table->covering_keys.intersect(field->part_of_key);
3680
 
        /* purecov: end */
3681
 
      }
3682
 
    }
3683
 
  }
3684
 
  fixed= 1;
3685
 
mark_non_agg_field:
3686
 
  return false;
3687
 
 
3688
 
error:
3689
 
  context->process_error(thd);
3690
 
  return true;
3691
 
}
3692
 
 
3693
 
Item *Item_field::safe_charset_converter(const CHARSET_INFO * const tocs)
3694
 
{
3695
 
  no_const_subst= 1;
3696
 
  return Item::safe_charset_converter(tocs);
3697
 
}
3698
 
 
3699
 
 
3700
 
void Item_field::cleanup()
3701
 
{
3702
 
  Item_ident::cleanup();
3703
 
  /*
3704
 
    Even if this object was created by direct link to field in setup_wild()
3705
 
    it will be linked correctly next time by name of field and table alias.
3706
 
    I.e. we can drop 'field'.
3707
 
   */
3708
 
  field= result_field= 0;
3709
 
  null_value= false;
3710
 
  return;
3711
 
}
3712
 
 
3713
 
/**
3714
 
  Find a field among specified multiple equalities.
3715
 
 
3716
 
  The function first searches the field among multiple equalities
3717
 
  of the current level (in the cond_equal->current_level list).
3718
 
  If it fails, it continues searching in upper levels accessed
3719
 
  through a pointer cond_equal->upper_levels.
3720
 
  The search terminates as soon as a multiple equality containing 
3721
 
  the field is found. 
3722
 
 
3723
 
  @param cond_equal   reference to list of multiple equalities where
3724
 
                      the field (this object) is to be looked for
3725
 
 
3726
 
  @return
3727
 
    - First Item_equal containing the field, if success
3728
 
    - 0, otherwise
3729
 
*/
3730
 
 
3731
 
Item_equal *Item_field::find_item_equal(COND_EQUAL *cond_equal)
3732
 
{
3733
 
  Item_equal *item= 0;
3734
 
  while (cond_equal)
3735
 
  {
3736
 
    List_iterator_fast<Item_equal> li(cond_equal->current_level);
3737
 
    while ((item= li++))
3738
 
    {
3739
 
      if (item->contains(field))
3740
 
        return item;
3741
 
    }
3742
 
    /* 
3743
 
      The field is not found in any of the multiple equalities
3744
 
      of the current level. Look for it in upper levels
3745
 
    */
3746
 
    cond_equal= cond_equal->upper_levels;
3747
 
  }
3748
 
  return 0;
3749
 
}
3750
 
 
3751
 
 
3752
 
/**
3753
 
  Check whether a field can be substituted by an equal item.
3754
 
 
3755
 
  The function checks whether a substitution of the field
3756
 
  occurrence for an equal item is valid.
3757
 
 
3758
 
  @param arg   *arg != NULL <-> the field is in the context where
3759
 
               substitution for an equal item is valid
3760
 
 
3761
 
  @note
3762
 
    The following statement is not always true:
3763
 
  @n
3764
 
    x=y => F(x)=F(x/y).
3765
 
  @n
3766
 
    This means substitution of an item for an equal item not always
3767
 
    yields an equavalent condition. Here's an example:
3768
 
    @code
3769
 
    'a'='a '
3770
 
    (LENGTH('a')=1) != (LENGTH('a ')=2)
3771
 
  @endcode
3772
 
    Such a substitution is surely valid if either the substituted
3773
 
    field is not of a STRING type or if it is an argument of
3774
 
    a comparison predicate.
3775
 
 
3776
 
  @retval
3777
 
    true   substitution is valid
3778
 
  @retval
3779
 
    false  otherwise
3780
 
*/
3781
 
 
3782
 
bool Item_field::subst_argument_checker(uchar **arg)
3783
 
{
3784
 
  return (result_type() != STRING_RESULT) || (*arg);
3785
 
}
3786
 
 
3787
 
 
3788
 
/**
3789
 
  Set a pointer to the multiple equality the field reference belongs to
3790
 
  (if any).
3791
 
 
3792
 
  The function looks for a multiple equality containing the field item
3793
 
  among those referenced by arg.
3794
 
  In the case such equality exists the function does the following.
3795
 
  If the found multiple equality contains a constant, then the field
3796
 
  reference is substituted for this constant, otherwise it sets a pointer
3797
 
  to the multiple equality in the field item.
3798
 
 
3799
 
 
3800
 
  @param arg    reference to list of multiple equalities where
3801
 
                the field (this object) is to be looked for
3802
 
 
3803
 
  @note
3804
 
    This function is supposed to be called as a callback parameter in calls
3805
 
    of the compile method.
3806
 
 
3807
 
  @return
3808
 
    - pointer to the replacing constant item, if the field item was substituted
3809
 
    - pointer to the field item, otherwise.
3810
 
*/
3811
 
 
3812
 
Item *Item_field::equal_fields_propagator(uchar *arg)
3813
 
{
3814
 
  if (no_const_subst)
3815
 
    return this;
3816
 
  item_equal= find_item_equal((COND_EQUAL *) arg);
3817
 
  Item *item= 0;
3818
 
  if (item_equal)
3819
 
    item= item_equal->get_const();
3820
 
  /*
3821
 
    Disable const propagation for items used in different comparison contexts.
3822
 
    This must be done because, for example, Item_hex_string->val_int() is not
3823
 
    the same as (Item_hex_string->val_str() in BINARY column)->val_int().
3824
 
    We cannot simply disable the replacement in a particular context (
3825
 
    e.g. <bin_col> = <int_col> AND <bin_col> = <hex_string>) since
3826
 
    Items don't know the context they are in and there are functions like 
3827
 
    IF (<hex_string>, 'yes', 'no').
3828
 
    The same problem occurs when comparing a DATE/TIME field with a
3829
 
    DATE/TIME represented as an int and as a string.
3830
 
  */
3831
 
  if (!item ||
3832
 
      (cmp_context != (Item_result)-1 && item->cmp_context != cmp_context))
3833
 
    item= this;
3834
 
 
3835
 
  return item;
3836
 
}
3837
 
 
3838
 
 
3839
 
/**
3840
 
  Mark the item to not be part of substitution if it's not a binary item.
3841
 
 
3842
 
  See comments in Arg_comparator::set_compare_func() for details.
3843
 
*/
3844
 
 
3845
 
bool Item_field::set_no_const_sub(uchar *arg __attribute__((unused)))
3846
 
{
3847
 
  if (field->charset() != &my_charset_bin)
3848
 
    no_const_subst=1;
3849
 
  return false;
3850
 
}
3851
 
 
3852
 
 
3853
 
/**
3854
 
  Replace an Item_field for an equal Item_field that evaluated earlier
3855
 
  (if any).
3856
 
 
3857
 
  The function returns a pointer to an item that is taken from
3858
 
  the very beginning of the item_equal list which the Item_field
3859
 
  object refers to (belongs to) unless item_equal contains  a constant
3860
 
  item. In this case the function returns this constant item, 
3861
 
  (if the substitution does not require conversion).   
3862
 
  If the Item_field object does not refer any Item_equal object
3863
 
  'this' is returned .
3864
 
 
3865
 
  @param arg   a dummy parameter, is not used here
3866
 
 
3867
 
 
3868
 
  @note
3869
 
    This function is supposed to be called as a callback parameter in calls
3870
 
    of the thransformer method.
3871
 
 
3872
 
  @return
3873
 
    - pointer to a replacement Item_field if there is a better equal item or
3874
 
      a pointer to a constant equal item;
3875
 
    - this - otherwise.
3876
 
*/
3877
 
 
3878
 
Item *Item_field::replace_equal_field(uchar *arg __attribute__((unused)))
3879
 
{
3880
 
  if (item_equal)
3881
 
  {
3882
 
    Item *const_item= item_equal->get_const();
3883
 
    if (const_item)
3884
 
    {
3885
 
      if (cmp_context != (Item_result)-1 &&
3886
 
          const_item->cmp_context != cmp_context)
3887
 
        return this;
3888
 
      return const_item;
3889
 
    }
3890
 
    Item_field *subst= item_equal->get_first();
3891
 
    if (subst && !field->eq(subst->field))
3892
 
      return subst;
3893
 
  }
3894
 
  return this;
3895
 
}
3896
 
 
3897
 
 
3898
 
void Item::init_make_field(Send_field *tmp_field,
 
1012
void Item::init_make_field(SendField *tmp_field,
3899
1013
                           enum enum_field_types field_type_arg)
3900
1014
{
3901
1015
  char *empty_name= (char*) "";
3902
 
  tmp_field->db_name=           empty_name;
3903
 
  tmp_field->org_table_name=    empty_name;
3904
 
  tmp_field->org_col_name=      empty_name;
3905
 
  tmp_field->table_name=        empty_name;
3906
 
  tmp_field->col_name=          name;
3907
 
  tmp_field->charsetnr=         collation.collation->number;
3908
 
  tmp_field->flags=             (maybe_null ? 0 : NOT_NULL_FLAG) | 
3909
 
                                (my_binary_compare(collation.collation) ?
3910
 
                                 BINARY_FLAG : 0);
3911
 
  tmp_field->type=              field_type_arg;
3912
 
  tmp_field->length=max_length;
3913
 
  tmp_field->decimals=decimals;
3914
 
  if (unsigned_flag)
3915
 
    tmp_field->flags |= UNSIGNED_FLAG;
 
1016
  tmp_field->db_name=   empty_name;
 
1017
  tmp_field->org_table_name= empty_name;
 
1018
  tmp_field->org_col_name= empty_name;
 
1019
  tmp_field->table_name= empty_name;
 
1020
  tmp_field->col_name= name;
 
1021
  tmp_field->charsetnr= collation.collation->number;
 
1022
  tmp_field->flags= (maybe_null ? 0 : NOT_NULL_FLAG) |
 
1023
                    (my_binary_compare(collation.collation) ?
 
1024
                      BINARY_FLAG : 0);
 
1025
  tmp_field->type= field_type_arg;
 
1026
  tmp_field->length= max_length;
 
1027
  tmp_field->decimals= decimals;
3916
1028
}
3917
1029
 
3918
 
void Item::make_field(Send_field *tmp_field)
 
1030
void Item::make_field(SendField *tmp_field)
3919
1031
{
3920
1032
  init_make_field(tmp_field, field_type());
3921
1033
}
3922
1034
 
3923
 
 
3924
1035
enum_field_types Item::string_field_type() const
3925
1036
{
3926
1037
  enum_field_types f_type= DRIZZLE_TYPE_VARCHAR;
3929
1040
  return f_type;
3930
1041
}
3931
1042
 
3932
 
 
3933
 
void Item_empty_string::make_field(Send_field *tmp_field)
3934
 
{
3935
 
  init_make_field(tmp_field, string_field_type());
3936
 
}
3937
 
 
3938
 
 
3939
1043
enum_field_types Item::field_type() const
3940
1044
{
3941
1045
  switch (result_type()) {
3942
 
  case STRING_RESULT:  return string_field_type();
3943
 
  case INT_RESULT:     return DRIZZLE_TYPE_LONGLONG;
3944
 
  case DECIMAL_RESULT: return DRIZZLE_TYPE_NEWDECIMAL;
3945
 
  case REAL_RESULT:    return DRIZZLE_TYPE_DOUBLE;
 
1046
  case STRING_RESULT:  
 
1047
    return string_field_type();
 
1048
  case INT_RESULT:     
 
1049
    return DRIZZLE_TYPE_LONGLONG;
 
1050
  case DECIMAL_RESULT: 
 
1051
    return DRIZZLE_TYPE_DECIMAL;
 
1052
  case REAL_RESULT:    
 
1053
    return DRIZZLE_TYPE_DOUBLE;
3946
1054
  case ROW_RESULT:
3947
1055
  default:
3948
1056
    assert(0);
3950
1058
  }
3951
1059
}
3952
1060
 
3953
 
 
3954
1061
bool Item::is_datetime()
3955
1062
{
3956
1063
  switch (field_type())
3957
1064
  {
3958
 
    case DRIZZLE_TYPE_NEWDATE:
 
1065
    case DRIZZLE_TYPE_DATE:
3959
1066
    case DRIZZLE_TYPE_DATETIME:
3960
1067
    case DRIZZLE_TYPE_TIMESTAMP:
3961
1068
      return true;
3965
1072
  return false;
3966
1073
}
3967
1074
 
3968
 
 
3969
1075
String *Item::check_well_formed_result(String *str, bool send_error)
3970
1076
{
3971
1077
  /* Check whether we got a well-formed string */
3972
1078
  const CHARSET_INFO * const cs= str->charset();
3973
1079
  int well_formed_error;
3974
 
  uint wlen= cs->cset->well_formed_len(cs,
 
1080
  uint32_t wlen= cs->cset->well_formed_len(cs,
3975
1081
                                       str->ptr(), str->ptr() + str->length(),
3976
1082
                                       str->length(), &well_formed_error);
3977
1083
  if (wlen < str->length())
3978
1084
  {
3979
 
    THD *thd= current_thd;
 
1085
    Session *session= current_session;
3980
1086
    char hexbuf[7];
3981
1087
    enum DRIZZLE_ERROR::enum_warning_level level;
3982
 
    uint diff= str->length() - wlen;
3983
 
    set_if_smaller(diff, 3);
3984
 
    octet2hex(hexbuf, str->ptr() + wlen, diff);
 
1088
    uint32_t diff= str->length() - wlen;
 
1089
    set_if_smaller(diff, 3U);
 
1090
    (void) drizzled_string_to_hex(hexbuf, str->ptr() + wlen, diff);
3985
1091
    if (send_error)
3986
1092
    {
3987
1093
      my_error(ER_INVALID_CHARACTER_STRING, MYF(0),
3988
1094
               cs->csname,  hexbuf);
3989
 
      return 0;
 
1095
      return NULL;
3990
1096
    }
3991
1097
    {
3992
1098
      level= DRIZZLE_ERROR::WARN_LEVEL_ERROR;
3993
1099
      null_value= 1;
3994
1100
      str= 0;
3995
1101
    }
3996
 
    push_warning_printf(thd, level, ER_INVALID_CHARACTER_STRING,
 
1102
    push_warning_printf(session, level, ER_INVALID_CHARACTER_STRING,
3997
1103
                        ER(ER_INVALID_CHARACTER_STRING), cs->csname, hexbuf);
3998
1104
  }
3999
1105
  return str;
4000
1106
}
4001
1107
 
4002
 
/*
4003
 
  Compare two items using a given collation
4004
 
  
4005
 
  SYNOPSIS
4006
 
    eq_by_collation()
4007
 
    item               item to compare with
4008
 
    binary_cmp         true <-> compare as binaries
4009
 
    cs                 collation to use when comparing strings
4010
 
 
4011
 
  DESCRIPTION
4012
 
    This method works exactly as Item::eq if the collation cs coincides with
4013
 
    the collation of the compared objects. Otherwise, first the collations that
4014
 
    differ from cs are replaced for cs and then the items are compared by
4015
 
    Item::eq. After the comparison the original collations of items are
4016
 
    restored.
4017
 
 
4018
 
  RETURN
4019
 
    1    compared items has been detected as equal   
4020
 
    0    otherwise
4021
 
*/
4022
 
 
4023
1108
bool Item::eq_by_collation(Item *item, bool binary_cmp, const CHARSET_INFO * const cs)
4024
1109
{
4025
1110
  const CHARSET_INFO *save_cs= 0;
4040
1125
  if (save_item_cs)
4041
1126
    item->collation.collation= save_item_cs;
4042
1127
  return res;
4043
 
}  
4044
 
 
4045
 
 
4046
 
/**
4047
 
  Create a field to hold a string value from an item.
4048
 
 
4049
 
  If max_length > CONVERT_IF_BIGGER_TO_BLOB create a blob @n
4050
 
  If max_length > 0 create a varchar @n
4051
 
  If max_length == 0 create a CHAR(0) 
4052
 
 
4053
 
  @param table          Table for which the field is created
4054
 
*/
4055
 
 
4056
 
Field *Item::make_string_field(TABLE *table)
 
1128
}
 
1129
 
 
1130
Field *Item::make_string_field(Table *table)
4057
1131
{
4058
1132
  Field *field;
4059
1133
  assert(collation.collation);
4069
1143
  return field;
4070
1144
}
4071
1145
 
4072
 
 
4073
 
/**
4074
 
  Create a field based on field_type of argument.
4075
 
 
4076
 
  For now, this is only used to create a field for
4077
 
  IFNULL(x,something) and time functions
4078
 
 
4079
 
  @retval
4080
 
    NULL  error
4081
 
  @retval
4082
 
    \#    Created field
4083
 
*/
4084
 
 
4085
 
Field *Item::tmp_table_field_from_field_type(TABLE *table, bool fixed_length __attribute__((unused)))
 
1146
Field *Item::tmp_table_field_from_field_type(Table *table, bool)
4086
1147
{
4087
1148
  /*
4088
1149
    The field functions defines a field to be not null if null_ptr is not 0
4089
1150
  */
4090
 
  uchar *null_ptr= maybe_null ? (uchar*) "" : 0;
 
1151
  unsigned char *null_ptr= maybe_null ? (unsigned char*) "" : 0;
4091
1152
  Field *field;
4092
1153
 
4093
1154
  switch (field_type()) {
4094
 
  case DRIZZLE_TYPE_NEWDECIMAL:
4095
 
    field= new Field_new_decimal((uchar*) 0, max_length, null_ptr, 0,
4096
 
                                 Field::NONE, name, decimals, 0,
 
1155
  case DRIZZLE_TYPE_DECIMAL:
 
1156
    field= new Field_decimal((unsigned char*) 0,
 
1157
                                 max_length,
 
1158
                                 null_ptr,
 
1159
                                 0,
 
1160
                                 Field::NONE,
 
1161
                                 name,
 
1162
                                 decimals,
 
1163
                                 0,
4097
1164
                                 unsigned_flag);
4098
1165
    break;
4099
 
  case DRIZZLE_TYPE_TINY:
4100
 
    field= new Field_tiny((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4101
 
                          name, 0, unsigned_flag);
4102
 
    break;
4103
 
  case DRIZZLE_TYPE_SHORT:
4104
 
    field= new Field_short((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
4105
 
                           name, 0, unsigned_flag);
4106
 
    break;
4107
1166
  case DRIZZLE_TYPE_LONG:
4108
 
    field= new Field_long((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
 
1167
    field= new Field_long((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE,
4109
1168
                          name, 0, unsigned_flag);
4110
1169
    break;
4111
1170
  case DRIZZLE_TYPE_LONGLONG:
4112
 
    field= new Field_int64_t((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
 
1171
    field= new Field_int64_t((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE,
4113
1172
                              name, 0, unsigned_flag);
4114
1173
    break;
4115
1174
  case DRIZZLE_TYPE_DOUBLE:
4116
 
    field= new Field_double((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
 
1175
    field= new Field_double((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE,
4117
1176
                            name, decimals, 0, unsigned_flag);
4118
1177
    break;
4119
1178
  case DRIZZLE_TYPE_NULL:
4120
 
    field= new Field_null((uchar*) 0, max_length, Field::NONE,
4121
 
                          name, &my_charset_bin);
4122
 
    break;
4123
 
  case DRIZZLE_TYPE_NEWDATE:
4124
 
    field= new Field_newdate(maybe_null, name, &my_charset_bin);
4125
 
    break;
4126
 
  case DRIZZLE_TYPE_TIME:
4127
 
    field= new Field_time(maybe_null, name, &my_charset_bin);
 
1179
    field= new Field_null((unsigned char*) 0, max_length, name, &my_charset_bin);
 
1180
    break;
 
1181
  case DRIZZLE_TYPE_DATE:
 
1182
    field= new Field_date(maybe_null, name, &my_charset_bin);
4128
1183
    break;
4129
1184
  case DRIZZLE_TYPE_TIMESTAMP:
4130
1185
    field= new Field_timestamp(maybe_null, name, &my_charset_bin);
4152
1207
  return field;
4153
1208
}
4154
1209
 
4155
 
 
4156
 
/* ARGSUSED */
4157
 
void Item_field::make_field(Send_field *tmp_field)
4158
 
{
4159
 
  field->make_field(tmp_field);
4160
 
  assert(tmp_field->table_name != 0);
4161
 
  if (name)
4162
 
    tmp_field->col_name=name;                   // Use user supplied name
4163
 
  if (table_name)
4164
 
    tmp_field->table_name= table_name;
4165
 
  if (db_name)
4166
 
    tmp_field->db_name= db_name;
4167
 
}
4168
 
 
4169
 
 
4170
 
/**
4171
 
  Set a field's value from a item.
4172
 
*/
4173
 
 
4174
 
void Item_field::save_org_in_field(Field *to)
4175
 
{
4176
 
  if (field->is_null())
4177
 
  {
4178
 
    null_value=1;
4179
 
    set_field_to_null_with_conversions(to, 1);
4180
 
  }
4181
 
  else
4182
 
  {
4183
 
    to->set_notnull();
4184
 
    field_conv(to,field);
4185
 
    null_value=0;
4186
 
  }
4187
 
}
4188
 
 
4189
 
int Item_field::save_in_field(Field *to, bool no_conversions)
4190
 
{
4191
 
  int res;
4192
 
  if (result_field->is_null())
4193
 
  {
4194
 
    null_value=1;
4195
 
    res= set_field_to_null_with_conversions(to, no_conversions);
4196
 
  }
4197
 
  else
4198
 
  {
4199
 
    to->set_notnull();
4200
 
    res= field_conv(to,result_field);
4201
 
    null_value=0;
4202
 
  }
4203
 
  return(res);
4204
 
}
4205
 
 
4206
 
 
4207
 
/**
4208
 
  Store null in field.
4209
 
 
4210
 
  This is used on INSERT.
4211
 
  Allow NULL to be inserted in timestamp and auto_increment values.
4212
 
 
4213
 
  @param field          Field where we want to store NULL
4214
 
 
4215
 
  @retval
4216
 
    0   ok
4217
 
  @retval
4218
 
    1   Field doesn't support NULL values and can't handle 'field = NULL'
4219
 
*/
4220
 
 
4221
 
int Item_null::save_in_field(Field *field, bool no_conversions)
4222
 
{
4223
 
  return set_field_to_null_with_conversions(field, no_conversions);
4224
 
}
4225
 
 
4226
 
 
4227
 
/**
4228
 
  Store null in field.
4229
 
 
4230
 
  @param field          Field where we want to store NULL
4231
 
 
4232
 
  @retval
4233
 
    0    OK
4234
 
  @retval
4235
 
    1    Field doesn't support NULL values
4236
 
*/
4237
 
 
4238
 
int Item_null::save_safe_in_field(Field *field)
4239
 
{
4240
 
  return set_field_to_null(field);
4241
 
}
4242
 
 
4243
 
 
4244
1210
/*
4245
1211
  This implementation can lose str_value content, so if the
4246
1212
  Item uses str_value to store something, it should
4247
1213
  reimplement it's ::save_in_field() as Item_string, for example, does
4248
1214
*/
4249
 
 
4250
1215
int Item::save_in_field(Field *field, bool no_conversions)
4251
1216
{
4252
1217
  int error;
4306
1271
  return error;
4307
1272
}
4308
1273
 
4309
 
 
4310
 
int Item_string::save_in_field(Field *field,
4311
 
                               bool no_conversions __attribute__((unused)))
4312
 
{
4313
 
  String *result;
4314
 
  result=val_str(&str_value);
4315
 
  return save_str_value_in_field(field, result);
4316
 
}
4317
 
 
4318
 
 
4319
 
int Item_uint::save_in_field(Field *field, bool no_conversions)
4320
 
{
4321
 
  /* Item_int::save_in_field handles both signed and unsigned. */
4322
 
  return Item_int::save_in_field(field, no_conversions);
4323
 
}
4324
 
 
4325
 
 
4326
 
int Item_int::save_in_field(Field *field,
4327
 
                            bool no_conversions __attribute__((unused)))
4328
 
{
4329
 
  int64_t nr=val_int();
4330
 
  if (null_value)
4331
 
    return set_field_to_null(field);
4332
 
  field->set_notnull();
4333
 
  return field->store(nr, unsigned_flag);
4334
 
}
4335
 
 
4336
 
 
4337
 
int Item_decimal::save_in_field(Field *field,
4338
 
                                bool no_conversions __attribute__((unused)))
4339
 
{
4340
 
  field->set_notnull();
4341
 
  return field->store_decimal(&decimal_value);
4342
 
}
4343
 
 
4344
 
 
4345
 
bool Item_int::eq(const Item *arg,
4346
 
                  bool binary_cmp __attribute__((unused))) const
4347
 
{
4348
 
  /* No need to check for null value as basic constant can't be NULL */
4349
 
  if (arg->basic_const_item() && arg->type() == type())
4350
 
  {
4351
 
    /*
4352
 
      We need to cast off const to call val_int(). This should be OK for
4353
 
      a basic constant.
4354
 
    */
4355
 
    Item *item= (Item*) arg;
4356
 
    return item->val_int() == value && item->unsigned_flag == unsigned_flag;
4357
 
  }
4358
 
  return false;
4359
 
}
4360
 
 
4361
 
 
4362
 
Item *Item_int_with_ref::clone_item()
4363
 
{
4364
 
  assert(ref->const_item());
4365
 
  /*
4366
 
    We need to evaluate the constant to make sure it works with
4367
 
    parameter markers.
4368
 
  */
4369
 
  return (ref->unsigned_flag ?
4370
 
          new Item_uint(ref->name, ref->val_int(), ref->max_length) :
4371
 
          new Item_int(ref->name, ref->val_int(), ref->max_length));
4372
 
}
4373
 
 
4374
 
 
4375
 
Item_num *Item_uint::neg()
4376
 
{
4377
 
  Item_decimal *item= new Item_decimal(value, 1);
4378
 
  return item->neg();
4379
 
}
4380
 
 
4381
 
 
4382
 
static uint nr_of_decimals(const char *str, const char *end)
4383
 
{
4384
 
  const char *decimal_point;
4385
 
 
4386
 
  /* Find position for '.' */
4387
 
  for (;;)
4388
 
  {
4389
 
    if (str == end)
4390
 
      return 0;
4391
 
    if (*str == 'e' || *str == 'E')
4392
 
      return NOT_FIXED_DEC;    
4393
 
    if (*str++ == '.')
4394
 
      break;
4395
 
  }
4396
 
  decimal_point= str;
4397
 
  for (; my_isdigit(system_charset_info, *str) ; str++)
4398
 
    ;
4399
 
  if (*str == 'e' || *str == 'E')
4400
 
    return NOT_FIXED_DEC;
4401
 
  return (uint) (str - decimal_point);
4402
 
}
4403
 
 
4404
 
 
4405
 
/**
4406
 
  This function is only called during parsing. We will signal an error if
4407
 
  value is not a true double value (overflow)
4408
 
*/
4409
 
 
4410
 
Item_float::Item_float(const char *str_arg, uint length)
4411
 
{
4412
 
  int error;
4413
 
  char *end_not_used;
4414
 
  value= my_strntod(&my_charset_bin, (char*) str_arg, length, &end_not_used,
4415
 
                    &error);
4416
 
  if (error)
4417
 
  {
4418
 
    /*
4419
 
      Note that we depend on that str_arg is null terminated, which is true
4420
 
      when we are in the parser
4421
 
    */
4422
 
    assert(str_arg[length] == 0);
4423
 
    my_error(ER_ILLEGAL_VALUE_FOR_TYPE, MYF(0), "double", (char*) str_arg);
4424
 
  }
4425
 
  presentation= name=(char*) str_arg;
4426
 
  decimals=(uint8_t) nr_of_decimals(str_arg, str_arg+length);
4427
 
  max_length=length;
4428
 
  fixed= 1;
4429
 
}
4430
 
 
4431
 
 
4432
 
int Item_float::save_in_field(Field *field,
4433
 
                              bool no_conversions __attribute__((unused)))
4434
 
{
4435
 
  double nr= val_real();
4436
 
  if (null_value)
4437
 
    return set_field_to_null(field);
4438
 
  field->set_notnull();
4439
 
  return field->store(nr);
4440
 
}
4441
 
 
4442
 
 
4443
 
void Item_float::print(String *str,
4444
 
                       enum_query_type query_type __attribute__((unused)))
4445
 
{
4446
 
  if (presentation)
4447
 
  {
4448
 
    str->append(presentation);
4449
 
    return;
4450
 
  }
4451
 
  char buffer[20];
4452
 
  String num(buffer, sizeof(buffer), &my_charset_bin);
4453
 
  num.set_real(value, decimals, &my_charset_bin);
4454
 
  str->append(num);
4455
 
}
4456
 
 
4457
 
 
4458
 
/*
4459
 
  hex item
4460
 
  In string context this is a binary string.
4461
 
  In number context this is a int64_t value.
4462
 
*/
4463
 
 
4464
 
bool Item_float::eq(const Item *arg,
4465
 
                    bool binary_cmp __attribute__((unused))) const
4466
 
{
4467
 
  if (arg->basic_const_item() && arg->type() == type())
4468
 
  {
4469
 
    /*
4470
 
      We need to cast off const to call val_int(). This should be OK for
4471
 
      a basic constant.
4472
 
    */
4473
 
    Item *item= (Item*) arg;
4474
 
    return item->val_real() == value;
4475
 
  }
4476
 
  return false;
4477
 
}
4478
 
 
4479
 
 
4480
 
inline uint char_val(char X)
4481
 
{
4482
 
  return (uint) (X >= '0' && X <= '9' ? X-'0' :
4483
 
                 X >= 'A' && X <= 'Z' ? X-'A'+10 :
4484
 
                 X-'a'+10);
4485
 
}
4486
 
 
4487
 
 
4488
 
Item_hex_string::Item_hex_string(const char *str, uint str_length)
4489
 
{
4490
 
  max_length=(str_length+1)/2;
4491
 
  char *ptr=(char*) sql_alloc(max_length+1);
4492
 
  if (!ptr)
4493
 
    return;
4494
 
  str_value.set(ptr,max_length,&my_charset_bin);
4495
 
  char *end=ptr+max_length;
4496
 
  if (max_length*2 != str_length)
4497
 
    *ptr++=char_val(*str++);                    // Not even, assume 0 prefix
4498
 
  while (ptr != end)
4499
 
  {
4500
 
    *ptr++= (char) (char_val(str[0])*16+char_val(str[1]));
4501
 
    str+=2;
4502
 
  }
4503
 
  *ptr=0;                                       // Keep purify happy
4504
 
  collation.set(&my_charset_bin, DERIVATION_COERCIBLE);
4505
 
  fixed= 1;
4506
 
  unsigned_flag= 1;
4507
 
}
4508
 
 
4509
 
int64_t Item_hex_string::val_int()
4510
 
{
4511
 
  // following assert is redundant, because fixed=1 assigned in constructor
4512
 
  assert(fixed == 1);
4513
 
  char *end=(char*) str_value.ptr()+str_value.length(),
4514
 
       *ptr=end-min(str_value.length(),(uint32_t)sizeof(int64_t));
4515
 
 
4516
 
  uint64_t value=0;
4517
 
  for (; ptr != end ; ptr++)
4518
 
    value=(value << 8)+ (uint64_t) (uchar) *ptr;
4519
 
  return (int64_t) value;
4520
 
}
4521
 
 
4522
 
 
4523
 
my_decimal *Item_hex_string::val_decimal(my_decimal *decimal_value)
4524
 
{
4525
 
  // following assert is redundant, because fixed=1 assigned in constructor
4526
 
  assert(fixed == 1);
4527
 
  uint64_t value= (uint64_t)val_int();
4528
 
  int2my_decimal(E_DEC_FATAL_ERROR, value, true, decimal_value);
4529
 
  return (decimal_value);
4530
 
}
4531
 
 
4532
 
 
4533
 
int Item_hex_string::save_in_field(Field *field,
4534
 
                                   bool no_conversions __attribute__((unused)))
4535
 
{
4536
 
  field->set_notnull();
4537
 
  if (field->result_type() == STRING_RESULT)
4538
 
    return field->store(str_value.ptr(), str_value.length(), 
4539
 
                        collation.collation);
4540
 
 
4541
 
  uint64_t nr;
4542
 
  uint32_t length= str_value.length();
4543
 
  if (length > 8)
4544
 
  {
4545
 
    nr= field->flags & UNSIGNED_FLAG ? UINT64_MAX : INT64_MAX;
4546
 
    goto warn;
4547
 
  }
4548
 
  nr= (uint64_t) val_int();
4549
 
  if ((length == 8) && !(field->flags & UNSIGNED_FLAG) && (nr > INT64_MAX))
4550
 
  {
4551
 
    nr= INT64_MAX;
4552
 
    goto warn;
4553
 
  }
4554
 
  return field->store((int64_t) nr, true);  // Assume hex numbers are unsigned
4555
 
 
4556
 
warn:
4557
 
  if (!field->store((int64_t) nr, true))
4558
 
    field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE,
4559
 
                       1);
4560
 
  return 1;
4561
 
}
4562
 
 
4563
 
 
4564
 
void Item_hex_string::print(String *str,
4565
 
                            enum_query_type query_type __attribute__((unused)))
4566
 
{
4567
 
  char *end= (char*) str_value.ptr() + str_value.length(),
4568
 
       *ptr= end - min(str_value.length(), (uint32_t)sizeof(int64_t));
4569
 
  str->append("0x");
4570
 
  for (; ptr != end ; ptr++)
4571
 
  {
4572
 
    str->append(_dig_vec_lower[((uchar) *ptr) >> 4]);
4573
 
    str->append(_dig_vec_lower[((uchar) *ptr) & 0x0F]);
4574
 
  }
4575
 
}
4576
 
 
4577
 
 
4578
 
bool Item_hex_string::eq(const Item *arg, bool binary_cmp) const
4579
 
{
4580
 
  if (arg->basic_const_item() && arg->type() == type())
4581
 
  {
4582
 
    if (binary_cmp)
4583
 
      return !stringcmp(&str_value, &arg->str_value);
4584
 
    return !sortcmp(&str_value, &arg->str_value, collation.collation);
4585
 
  }
4586
 
  return false;
4587
 
}
4588
 
 
4589
 
 
4590
 
Item *Item_hex_string::safe_charset_converter(const CHARSET_INFO * const tocs)
4591
 
{
4592
 
  Item_string *conv;
4593
 
  String tmp, *str= val_str(&tmp);
4594
 
 
4595
 
  if (!(conv= new Item_string(str->ptr(), str->length(), tocs)))
4596
 
    return NULL;
4597
 
  conv->str_value.copy();
4598
 
  conv->str_value.mark_as_const();
4599
 
  return conv;
4600
 
}
4601
 
 
4602
 
 
4603
 
/*
4604
 
  bin item.
4605
 
  In string context this is a binary string.
4606
 
  In number context this is a int64_t value.
4607
 
*/
4608
 
  
4609
 
Item_bin_string::Item_bin_string(const char *str, uint str_length)
4610
 
{
4611
 
  const char *end= str + str_length - 1;
4612
 
  uchar bits= 0;
4613
 
  uint power= 1;
4614
 
 
4615
 
  max_length= (str_length + 7) >> 3;
4616
 
  char *ptr= (char*) sql_alloc(max_length + 1);
4617
 
  if (!ptr)
4618
 
    return;
4619
 
  str_value.set(ptr, max_length, &my_charset_bin);
4620
 
  ptr+= max_length - 1;
4621
 
  ptr[1]= 0;                     // Set end null for string
4622
 
  for (; end >= str; end--)
4623
 
  {
4624
 
    if (power == 256)
4625
 
    {
4626
 
      power= 1;
4627
 
      *ptr--= bits;
4628
 
      bits= 0;     
4629
 
    }
4630
 
    if (*end == '1')
4631
 
      bits|= power; 
4632
 
    power<<= 1;
4633
 
  }
4634
 
  *ptr= (char) bits;
4635
 
  collation.set(&my_charset_bin, DERIVATION_COERCIBLE);
4636
 
  fixed= 1;
4637
 
}
4638
 
 
4639
 
 
4640
 
/**
4641
 
  Pack data in buffer for sending.
4642
 
*/
4643
 
 
4644
 
bool Item_null::send(Protocol *protocol,
4645
 
                     String *packet __attribute__((unused)))
4646
 
{
4647
 
  return protocol->store_null();
4648
 
}
4649
 
 
4650
 
/**
4651
 
  This is only called from items that is not of type item_field.
4652
 
*/
4653
 
 
4654
 
bool Item::send(Protocol *protocol, String *buffer)
 
1274
bool Item::send(plugin::Client *client, String *buffer)
4655
1275
{
4656
1276
  bool result= false;
4657
1277
  enum_field_types f_type;
4662
1282
  case DRIZZLE_TYPE_ENUM:
4663
1283
  case DRIZZLE_TYPE_BLOB:
4664
1284
  case DRIZZLE_TYPE_VARCHAR:
4665
 
  case DRIZZLE_TYPE_NEWDECIMAL:
 
1285
  case DRIZZLE_TYPE_DECIMAL:
4666
1286
  {
4667
1287
    String *res;
4668
1288
    if ((res=val_str(buffer)))
4669
 
      result= protocol->store(res->ptr(),res->length(),res->charset());
4670
 
    break;
4671
 
  }
4672
 
  case DRIZZLE_TYPE_TINY:
4673
 
  {
4674
 
    int64_t nr;
4675
 
    nr= val_int();
4676
 
    if (!null_value)
4677
 
      result= protocol->store_tiny(nr);
4678
 
    break;
4679
 
  }
4680
 
  case DRIZZLE_TYPE_SHORT:
4681
 
  {
4682
 
    int64_t nr;
4683
 
    nr= val_int();
4684
 
    if (!null_value)
4685
 
      result= protocol->store_short(nr);
 
1289
      result= client->store(res->ptr(),res->length());
4686
1290
    break;
4687
1291
  }
4688
1292
  case DRIZZLE_TYPE_LONG:
4690
1294
    int64_t nr;
4691
1295
    nr= val_int();
4692
1296
    if (!null_value)
4693
 
      result= protocol->store_long(nr);
 
1297
      result= client->store((int32_t)nr);
4694
1298
    break;
4695
1299
  }
4696
1300
  case DRIZZLE_TYPE_LONGLONG:
4698
1302
    int64_t nr;
4699
1303
    nr= val_int();
4700
1304
    if (!null_value)
4701
 
      result= protocol->store_int64_t(nr, unsigned_flag);
 
1305
    {
 
1306
      if (unsigned_flag)
 
1307
        result= client->store((uint64_t)nr);
 
1308
      else
 
1309
        result= client->store((int64_t)nr);
 
1310
    }
4702
1311
    break;
4703
1312
  }
4704
1313
  case DRIZZLE_TYPE_DOUBLE:
4705
1314
  {
4706
1315
    double nr= val_real();
4707
1316
    if (!null_value)
4708
 
      result= protocol->store(nr, decimals, buffer);
 
1317
      result= client->store(nr, decimals, buffer);
4709
1318
    break;
4710
1319
  }
4711
1320
  case DRIZZLE_TYPE_DATETIME:
4714
1323
    DRIZZLE_TIME tm;
4715
1324
    get_date(&tm, TIME_FUZZY_DATE);
4716
1325
    if (!null_value)
4717
 
    {
4718
 
      if (f_type == DRIZZLE_TYPE_NEWDATE)
4719
 
        return protocol->store_date(&tm);
4720
 
      else
4721
 
        result= protocol->store(&tm);
4722
 
    }
4723
 
    break;
4724
 
  }
4725
 
  case DRIZZLE_TYPE_TIME:
4726
 
  {
4727
 
    DRIZZLE_TIME tm;
4728
 
    get_time(&tm);
4729
 
    if (!null_value)
4730
 
      result= protocol->store_time(&tm);
 
1326
      result= client->store(&tm);
4731
1327
    break;
4732
1328
  }
4733
1329
  }
4734
1330
  if (null_value)
4735
 
    result= protocol->store_null();
 
1331
    result= client->store();
4736
1332
  return result;
4737
1333
}
4738
1334
 
4739
 
 
4740
 
bool Item_field::send(Protocol *protocol,
4741
 
                      String *buffer __attribute__((unused)))
4742
 
{
4743
 
  return protocol->store(result_field);
4744
 
}
4745
 
 
4746
 
 
4747
 
void Item_field::update_null_value()
4748
 
{
4749
 
  /*
4750
 
    need to set no_errors to prevent warnings about type conversion
4751
 
    popping up.
4752
 
  */
4753
 
  THD *thd= field->table->in_use;
4754
 
  int no_errors;
4755
 
 
4756
 
  no_errors= thd->no_errors;
4757
 
  thd->no_errors= 1;
4758
 
  Item::update_null_value();
4759
 
  thd->no_errors= no_errors;
4760
 
}
4761
 
 
4762
 
 
4763
 
/*
4764
 
  Add the field to the select list and substitute it for the reference to
4765
 
  the field.
4766
 
 
4767
 
  SYNOPSIS
4768
 
    Item_field::update_value_transformer()
4769
 
    select_arg      current select
4770
 
 
4771
 
  DESCRIPTION
4772
 
    If the field doesn't belong to the table being inserted into then it is
4773
 
    added to the select list, pointer to it is stored in the ref_pointer_array
4774
 
    of the select and the field itself is substituted for the Item_ref object.
4775
 
    This is done in order to get correct values from update fields that
4776
 
    belongs to the SELECT part in the INSERT .. SELECT .. ON DUPLICATE KEY
4777
 
    UPDATE statement.
4778
 
 
4779
 
  RETURN
4780
 
    0             if error occured
4781
 
    ref           if all conditions are met
4782
 
    this field    otherwise
4783
 
*/
4784
 
 
4785
 
Item *Item_field::update_value_transformer(uchar *select_arg)
4786
 
{
4787
 
  SELECT_LEX *select= (SELECT_LEX*)select_arg;
4788
 
  assert(fixed);
4789
 
 
4790
 
  if (field->table != select->context.table_list->table &&
4791
 
      type() != Item::TRIGGER_FIELD_ITEM)
4792
 
  {
4793
 
    List<Item> *all_fields= &select->join->all_fields;
4794
 
    Item **ref_pointer_array= select->ref_pointer_array;
4795
 
    int el= all_fields->elements;
4796
 
    Item_ref *ref;
4797
 
 
4798
 
    ref_pointer_array[el]= (Item*)this;
4799
 
    all_fields->push_front((Item*)this);
4800
 
    ref= new Item_ref(&select->context, ref_pointer_array + el,
4801
 
                      table_name, field_name);
4802
 
    return ref;
4803
 
  }
4804
 
  return this;
4805
 
}
4806
 
 
4807
 
 
4808
 
void Item_field::print(String *str, enum_query_type query_type)
4809
 
{
4810
 
  if (field && field->table->const_table)
4811
 
  {
4812
 
    char buff[MAX_FIELD_WIDTH];
4813
 
    String tmp(buff,sizeof(buff),str->charset());
4814
 
    field->val_str(&tmp);
4815
 
    str->append('\'');
4816
 
    str->append(tmp);
4817
 
    str->append('\'');
4818
 
    return;
4819
 
  }
4820
 
  Item_ident::print(str, query_type);
4821
 
}
4822
 
 
4823
 
 
4824
 
Item_ref::Item_ref(Name_resolution_context *context_arg,
4825
 
                   Item **item, const char *table_name_arg,
4826
 
                   const char *field_name_arg,
4827
 
                   bool alias_name_used_arg)
4828
 
  :Item_ident(context_arg, NullS, table_name_arg, field_name_arg),
4829
 
   result_field(0), ref(item)
4830
 
{
4831
 
  alias_name_used= alias_name_used_arg;
4832
 
  /*
4833
 
    This constructor used to create some internals references over fixed items
4834
 
  */
4835
 
  if (ref && *ref && (*ref)->fixed)
4836
 
    set_properties();
4837
 
}
4838
 
 
4839
 
 
4840
 
/**
4841
 
  Resolve the name of a reference to a column reference.
4842
 
 
4843
 
  The method resolves the column reference represented by 'this' as a column
4844
 
  present in one of: GROUP BY clause, SELECT clause, outer queries. It is
4845
 
  used typically for columns in the HAVING clause which are not under
4846
 
  aggregate functions.
4847
 
 
4848
 
  POSTCONDITION @n
4849
 
  Item_ref::ref is 0 or points to a valid item.
4850
 
 
4851
 
  @note
4852
 
    The name resolution algorithm used is (where [T_j] is an optional table
4853
 
    name that qualifies the column name):
4854
 
 
4855
 
  @code
4856
 
        resolve_extended([T_j].col_ref_i)
4857
 
        {
4858
 
          Search for a column or derived column named col_ref_i [in table T_j]
4859
 
          in the SELECT and GROUP clauses of Q.
4860
 
 
4861
 
          if such a column is NOT found AND    // Lookup in outer queries.
4862
 
             there are outer queries
4863
 
          {
4864
 
            for each outer query Q_k beginning from the inner-most one
4865
 
           {
4866
 
              Search for a column or derived column named col_ref_i
4867
 
              [in table T_j] in the SELECT and GROUP clauses of Q_k.
4868
 
 
4869
 
              if such a column is not found AND
4870
 
                 - Q_k is not a group query AND
4871
 
                 - Q_k is not inside an aggregate function
4872
 
                 OR
4873
 
                 - Q_(k-1) is not in a HAVING or SELECT clause of Q_k
4874
 
              {
4875
 
                search for a column or derived column named col_ref_i
4876
 
                [in table T_j] in the FROM clause of Q_k;
4877
 
              }
4878
 
            }
4879
 
          }
4880
 
        }
4881
 
  @endcode
4882
 
  @n
4883
 
    This procedure treats GROUP BY and SELECT clauses as one namespace for
4884
 
    column references in HAVING. Notice that compared to
4885
 
    Item_field::fix_fields, here we first search the SELECT and GROUP BY
4886
 
    clauses, and then we search the FROM clause.
4887
 
 
4888
 
  @param[in]     thd        current thread
4889
 
  @param[in,out] reference  view column if this item was resolved to a
4890
 
    view column
4891
 
 
4892
 
  @todo
4893
 
    Here we could first find the field anyway, and then test this
4894
 
    condition, so that we can give a better error message -
4895
 
    ER_WRONG_FIELD_WITH_GROUP, instead of the less informative
4896
 
    ER_BAD_FIELD_ERROR which we produce now.
4897
 
 
4898
 
  @retval
4899
 
    true  if error
4900
 
  @retval
4901
 
    false on success
4902
 
*/
4903
 
 
4904
 
bool Item_ref::fix_fields(THD *thd, Item **reference)
4905
 
{
4906
 
  enum_parsing_place place= NO_MATTER;
4907
 
  assert(fixed == 0);
4908
 
  SELECT_LEX *current_sel= thd->lex->current_select;
4909
 
 
4910
 
  if (!ref || ref == not_found_item)
4911
 
  {
4912
 
    if (!(ref= resolve_ref_in_select_and_group(thd, this,
4913
 
                                               context->select_lex)))
4914
 
      goto error;             /* Some error occurred (e.g. ambiguous names). */
4915
 
 
4916
 
    if (ref == not_found_item) /* This reference was not resolved. */
4917
 
    {
4918
 
      Name_resolution_context *last_checked_context= context;
4919
 
      Name_resolution_context *outer_context= context->outer_context;
4920
 
      Field *from_field;
4921
 
      ref= 0;
4922
 
 
4923
 
      if (!outer_context)
4924
 
      {
4925
 
        /* The current reference cannot be resolved in this query. */
4926
 
        my_error(ER_BAD_FIELD_ERROR,MYF(0),
4927
 
                 this->full_name(), current_thd->where);
4928
 
        goto error;
4929
 
      }
4930
 
 
4931
 
      /*
4932
 
        If there is an outer context (select), and it is not a derived table
4933
 
        (which do not support the use of outer fields for now), try to
4934
 
        resolve this reference in the outer select(s).
4935
 
 
4936
 
        We treat each subselect as a separate namespace, so that different
4937
 
        subselects may contain columns with the same names. The subselects are
4938
 
        searched starting from the innermost.
4939
 
      */
4940
 
      from_field= (Field*) not_found_field;
4941
 
 
4942
 
      do
4943
 
      {
4944
 
        SELECT_LEX *select= outer_context->select_lex;
4945
 
        Item_subselect *prev_subselect_item=
4946
 
          last_checked_context->select_lex->master_unit()->item;
4947
 
        last_checked_context= outer_context;
4948
 
 
4949
 
        /* Search in the SELECT and GROUP lists of the outer select. */
4950
 
        if (outer_context->resolve_in_select_list)
4951
 
        {
4952
 
          if (!(ref= resolve_ref_in_select_and_group(thd, this, select)))
4953
 
            goto error; /* Some error occurred (e.g. ambiguous names). */
4954
 
          if (ref != not_found_item)
4955
 
          {
4956
 
            assert(*ref && (*ref)->fixed);
4957
 
            prev_subselect_item->used_tables_cache|= (*ref)->used_tables();
4958
 
            prev_subselect_item->const_item_cache&= (*ref)->const_item();
4959
 
            break;
4960
 
          }
4961
 
          /*
4962
 
            Set ref to 0 to ensure that we get an error in case we replaced
4963
 
            this item with another item and still use this item in some
4964
 
            other place of the parse tree.
4965
 
          */
4966
 
          ref= 0;
4967
 
        }
4968
 
 
4969
 
        place= prev_subselect_item->parsing_place;
4970
 
        /*
4971
 
          Check table fields only if the subquery is used somewhere out of
4972
 
          HAVING or the outer SELECT does not use grouping (i.e. tables are
4973
 
          accessible).
4974
 
          TODO:
4975
 
          Here we could first find the field anyway, and then test this
4976
 
          condition, so that we can give a better error message -
4977
 
          ER_WRONG_FIELD_WITH_GROUP, instead of the less informative
4978
 
          ER_BAD_FIELD_ERROR which we produce now.
4979
 
        */
4980
 
        if ((place != IN_HAVING ||
4981
 
             (!select->with_sum_func &&
4982
 
              select->group_list.elements == 0)))
4983
 
        {
4984
 
          /*
4985
 
            In case of view, find_field_in_tables() write pointer to view
4986
 
            field expression to 'reference', i.e. it substitute that
4987
 
            expression instead of this Item_ref
4988
 
          */
4989
 
          from_field= find_field_in_tables(thd, this,
4990
 
                                           outer_context->
4991
 
                                             first_name_resolution_table,
4992
 
                                           outer_context->
4993
 
                                             last_name_resolution_table,
4994
 
                                           reference,
4995
 
                                           IGNORE_EXCEPT_NON_UNIQUE,
4996
 
                                           true, true);
4997
 
          if (! from_field)
4998
 
            goto error;
4999
 
          if (from_field == view_ref_found)
5000
 
          {
5001
 
            Item::Type refer_type= (*reference)->type();
5002
 
            prev_subselect_item->used_tables_cache|=
5003
 
              (*reference)->used_tables();
5004
 
            prev_subselect_item->const_item_cache&=
5005
 
              (*reference)->const_item();
5006
 
            assert((*reference)->type() == REF_ITEM);
5007
 
            mark_as_dependent(thd, last_checked_context->select_lex,
5008
 
                              context->select_lex, this,
5009
 
                              ((refer_type == REF_ITEM ||
5010
 
                                refer_type == FIELD_ITEM) ?
5011
 
                               (Item_ident*) (*reference) :
5012
 
                               0));
5013
 
            /*
5014
 
              view reference found, we substituted it instead of this
5015
 
              Item, so can quit
5016
 
            */
5017
 
            return false;
5018
 
          }
5019
 
          if (from_field != not_found_field)
5020
 
          {
5021
 
            if (cached_table && cached_table->select_lex &&
5022
 
                outer_context->select_lex &&
5023
 
                cached_table->select_lex != outer_context->select_lex)
5024
 
            {
5025
 
              /*
5026
 
                Due to cache, find_field_in_tables() can return field which
5027
 
                doesn't belong to provided outer_context. In this case we have
5028
 
                to find proper field context in order to fix field correcly.
5029
 
              */
5030
 
              do
5031
 
              {
5032
 
                outer_context= outer_context->outer_context;
5033
 
                select= outer_context->select_lex;
5034
 
                prev_subselect_item=
5035
 
                  last_checked_context->select_lex->master_unit()->item;
5036
 
                last_checked_context= outer_context;
5037
 
              } while (outer_context && outer_context->select_lex &&
5038
 
                       cached_table->select_lex != outer_context->select_lex);
5039
 
            }
5040
 
            prev_subselect_item->used_tables_cache|= from_field->table->map;
5041
 
            prev_subselect_item->const_item_cache= 0;
5042
 
            break;
5043
 
          }
5044
 
        }
5045
 
        assert(from_field == not_found_field);
5046
 
 
5047
 
        /* Reference is not found => depend on outer (or just error). */
5048
 
        prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
5049
 
        prev_subselect_item->const_item_cache= 0;
5050
 
 
5051
 
        outer_context= outer_context->outer_context;
5052
 
      } while (outer_context);
5053
 
 
5054
 
      assert(from_field != 0 && from_field != view_ref_found);
5055
 
      if (from_field != not_found_field)
5056
 
      {
5057
 
        Item_field* fld;
5058
 
        if (!(fld= new Item_field(from_field)))
5059
 
          goto error;
5060
 
        thd->change_item_tree(reference, fld);
5061
 
        mark_as_dependent(thd, last_checked_context->select_lex,
5062
 
                          thd->lex->current_select, this, fld);
5063
 
        /*
5064
 
          A reference is resolved to a nest level that's outer or the same as
5065
 
          the nest level of the enclosing set function : adjust the value of
5066
 
          max_arg_level for the function if it's needed.
5067
 
        */
5068
 
        if (thd->lex->in_sum_func &&
5069
 
            thd->lex->in_sum_func->nest_level >= 
5070
 
            last_checked_context->select_lex->nest_level)
5071
 
          set_if_bigger(thd->lex->in_sum_func->max_arg_level,
5072
 
                        last_checked_context->select_lex->nest_level);
5073
 
        return false;
5074
 
      }
5075
 
      if (ref == 0)
5076
 
      {
5077
 
        /* The item was not a table field and not a reference */
5078
 
        my_error(ER_BAD_FIELD_ERROR, MYF(0),
5079
 
                 this->full_name(), current_thd->where);
5080
 
        goto error;
5081
 
      }
5082
 
      /* Should be checked in resolve_ref_in_select_and_group(). */
5083
 
      assert(*ref && (*ref)->fixed);
5084
 
      mark_as_dependent(thd, last_checked_context->select_lex,
5085
 
                        context->select_lex, this, this);
5086
 
      /*
5087
 
        A reference is resolved to a nest level that's outer or the same as
5088
 
        the nest level of the enclosing set function : adjust the value of
5089
 
        max_arg_level for the function if it's needed.
5090
 
      */
5091
 
      if (thd->lex->in_sum_func &&
5092
 
          thd->lex->in_sum_func->nest_level >= 
5093
 
          last_checked_context->select_lex->nest_level)
5094
 
        set_if_bigger(thd->lex->in_sum_func->max_arg_level,
5095
 
                      last_checked_context->select_lex->nest_level);
5096
 
    }
5097
 
  }
5098
 
 
5099
 
  assert(*ref);
5100
 
  /*
5101
 
    Check if this is an incorrect reference in a group function or forward
5102
 
    reference. Do not issue an error if this is:
5103
 
      1. outer reference (will be fixed later by the fix_inner_refs function);
5104
 
      2. an unnamed reference inside an aggregate function.
5105
 
  */
5106
 
  if (!((*ref)->type() == REF_ITEM &&
5107
 
       ((Item_ref *)(*ref))->ref_type() == OUTER_REF) &&
5108
 
      (((*ref)->with_sum_func && name &&
5109
 
        !(current_sel->linkage != GLOBAL_OPTIONS_TYPE &&
5110
 
          current_sel->having_fix_field)) ||
5111
 
       !(*ref)->fixed))
5112
 
  {
5113
 
    my_error(ER_ILLEGAL_REFERENCE, MYF(0),
5114
 
             name, ((*ref)->with_sum_func?
5115
 
                    "reference to group function":
5116
 
                    "forward reference in item list"));
5117
 
    goto error;
5118
 
  }
5119
 
 
5120
 
  set_properties();
5121
 
 
5122
 
  if ((*ref)->check_cols(1))
5123
 
    goto error;
5124
 
  return false;
5125
 
 
5126
 
error:
5127
 
  context->process_error(thd);
5128
 
  return true;
5129
 
}
5130
 
 
5131
 
 
5132
 
void Item_ref::set_properties()
5133
 
{
5134
 
  max_length= (*ref)->max_length;
5135
 
  maybe_null= (*ref)->maybe_null;
5136
 
  decimals=   (*ref)->decimals;
5137
 
  collation.set((*ref)->collation);
5138
 
  /*
5139
 
    We have to remember if we refer to a sum function, to ensure that
5140
 
    split_sum_func() doesn't try to change the reference.
5141
 
  */
5142
 
  with_sum_func= (*ref)->with_sum_func;
5143
 
  unsigned_flag= (*ref)->unsigned_flag;
5144
 
  fixed= 1;
5145
 
  if (alias_name_used)
5146
 
    return;
5147
 
  if ((*ref)->type() == FIELD_ITEM)
5148
 
    alias_name_used= ((Item_ident *) (*ref))->alias_name_used;
5149
 
  else
5150
 
    alias_name_used= true; // it is not field, so it is was resolved by alias
5151
 
}
5152
 
 
5153
 
 
5154
 
void Item_ref::cleanup()
5155
 
{
5156
 
  Item_ident::cleanup();
5157
 
  result_field= 0;
5158
 
  return;
5159
 
}
5160
 
 
5161
 
 
5162
 
void Item_ref::print(String *str, enum_query_type query_type)
5163
 
{
5164
 
  if (ref)
5165
 
  {
5166
 
    if ((*ref)->type() != Item::CACHE_ITEM && ref_type() != VIEW_REF &&
5167
 
        !table_name && name && alias_name_used)
5168
 
    {
5169
 
      THD *thd= current_thd;
5170
 
      append_identifier(thd, str, name, (uint) strlen(name));
5171
 
    }
5172
 
    else
5173
 
      (*ref)->print(str, query_type);
5174
 
  }
5175
 
  else
5176
 
    Item_ident::print(str, query_type);
5177
 
}
5178
 
 
5179
 
 
5180
 
bool Item_ref::send(Protocol *prot, String *tmp)
5181
 
{
5182
 
  if (result_field)
5183
 
    return prot->store(result_field);
5184
 
  return (*ref)->send(prot, tmp);
5185
 
}
5186
 
 
5187
 
 
5188
 
double Item_ref::val_result()
5189
 
{
5190
 
  if (result_field)
5191
 
  {
5192
 
    if ((null_value= result_field->is_null()))
5193
 
      return 0.0;
5194
 
    return result_field->val_real();
5195
 
  }
5196
 
  return val_real();
5197
 
}
5198
 
 
5199
 
 
5200
 
int64_t Item_ref::val_int_result()
5201
 
{
5202
 
  if (result_field)
5203
 
  {
5204
 
    if ((null_value= result_field->is_null()))
5205
 
      return 0;
5206
 
    return result_field->val_int();
5207
 
  }
5208
 
  return val_int();
5209
 
}
5210
 
 
5211
 
 
5212
 
String *Item_ref::str_result(String* str)
5213
 
{
5214
 
  if (result_field)
5215
 
  {
5216
 
    if ((null_value= result_field->is_null()))
5217
 
      return 0;
5218
 
    str->set_charset(str_value.charset());
5219
 
    return result_field->val_str(str, &str_value);
5220
 
  }
5221
 
  return val_str(str);
5222
 
}
5223
 
 
5224
 
 
5225
 
my_decimal *Item_ref::val_decimal_result(my_decimal *decimal_value)
5226
 
{
5227
 
  if (result_field)
5228
 
  {
5229
 
    if ((null_value= result_field->is_null()))
5230
 
      return 0;
5231
 
    return result_field->val_decimal(decimal_value);
5232
 
  }
5233
 
  return val_decimal(decimal_value);
5234
 
}
5235
 
 
5236
 
 
5237
 
bool Item_ref::val_bool_result()
5238
 
{
5239
 
  if (result_field)
5240
 
  {
5241
 
    if ((null_value= result_field->is_null()))
5242
 
      return 0;
5243
 
    switch (result_field->result_type()) {
5244
 
    case INT_RESULT:
5245
 
      return result_field->val_int() != 0;
5246
 
    case DECIMAL_RESULT:
5247
 
    {
5248
 
      my_decimal decimal_value;
5249
 
      my_decimal *val= result_field->val_decimal(&decimal_value);
5250
 
      if (val)
5251
 
        return !my_decimal_is_zero(val);
5252
 
      return 0;
5253
 
    }
5254
 
    case REAL_RESULT:
5255
 
    case STRING_RESULT:
5256
 
      return result_field->val_real() != 0.0;
5257
 
    case ROW_RESULT:
5258
 
    default:
5259
 
      assert(0);
5260
 
    }
5261
 
  }
5262
 
  return val_bool();
5263
 
}
5264
 
 
5265
 
 
5266
 
double Item_ref::val_real()
5267
 
{
5268
 
  assert(fixed);
5269
 
  double tmp=(*ref)->val_result();
5270
 
  null_value=(*ref)->null_value;
5271
 
  return tmp;
5272
 
}
5273
 
 
5274
 
 
5275
 
int64_t Item_ref::val_int()
5276
 
{
5277
 
  assert(fixed);
5278
 
  int64_t tmp=(*ref)->val_int_result();
5279
 
  null_value=(*ref)->null_value;
5280
 
  return tmp;
5281
 
}
5282
 
 
5283
 
 
5284
 
bool Item_ref::val_bool()
5285
 
{
5286
 
  assert(fixed);
5287
 
  bool tmp= (*ref)->val_bool_result();
5288
 
  null_value= (*ref)->null_value;
5289
 
  return tmp;
5290
 
}
5291
 
 
5292
 
 
5293
 
String *Item_ref::val_str(String* tmp)
5294
 
{
5295
 
  assert(fixed);
5296
 
  tmp=(*ref)->str_result(tmp);
5297
 
  null_value=(*ref)->null_value;
5298
 
  return tmp;
5299
 
}
5300
 
 
5301
 
 
5302
 
bool Item_ref::is_null()
5303
 
{
5304
 
  assert(fixed);
5305
 
  return (*ref)->is_null();
5306
 
}
5307
 
 
5308
 
 
5309
 
bool Item_ref::get_date(DRIZZLE_TIME *ltime,uint fuzzydate)
5310
 
{
5311
 
  return (null_value=(*ref)->get_date_result(ltime,fuzzydate));
5312
 
}
5313
 
 
5314
 
 
5315
 
my_decimal *Item_ref::val_decimal(my_decimal *decimal_value)
5316
 
{
5317
 
  my_decimal *val= (*ref)->val_decimal_result(decimal_value);
5318
 
  null_value= (*ref)->null_value;
5319
 
  return val;
5320
 
}
5321
 
 
5322
 
int Item_ref::save_in_field(Field *to, bool no_conversions)
5323
 
{
5324
 
  int res;
5325
 
  assert(!result_field);
5326
 
  res= (*ref)->save_in_field(to, no_conversions);
5327
 
  null_value= (*ref)->null_value;
5328
 
  return res;
5329
 
}
5330
 
 
5331
 
 
5332
 
void Item_ref::save_org_in_field(Field *field)
5333
 
{
5334
 
  (*ref)->save_org_in_field(field);
5335
 
}
5336
 
 
5337
 
 
5338
 
void Item_ref::make_field(Send_field *field)
5339
 
{
5340
 
  (*ref)->make_field(field);
5341
 
  /* Non-zero in case of a view */
5342
 
  if (name)
5343
 
    field->col_name= name;
5344
 
  if (table_name)
5345
 
    field->table_name= table_name;
5346
 
  if (db_name)
5347
 
    field->db_name= db_name;
5348
 
}
5349
 
 
5350
 
 
5351
 
Item *Item_ref::get_tmp_table_item(THD *thd)
5352
 
{
5353
 
  if (!result_field)
5354
 
    return (*ref)->get_tmp_table_item(thd);
5355
 
 
5356
 
  Item_field *item= new Item_field(result_field);
5357
 
  if (item)
5358
 
  {
5359
 
    item->table_name= table_name;
5360
 
    item->db_name= db_name;
5361
 
  }
5362
 
  return item;
5363
 
}
5364
 
 
5365
 
 
5366
 
void Item_ref_null_helper::print(String *str, enum_query_type query_type)
5367
 
{
5368
 
  str->append(STRING_WITH_LEN("<ref_null_helper>("));
5369
 
  if (ref)
5370
 
    (*ref)->print(str, query_type);
5371
 
  else
5372
 
    str->append('?');
5373
 
  str->append(')');
5374
 
}
5375
 
 
5376
 
 
5377
 
double Item_direct_ref::val_real()
5378
 
{
5379
 
  double tmp=(*ref)->val_real();
5380
 
  null_value=(*ref)->null_value;
5381
 
  return tmp;
5382
 
}
5383
 
 
5384
 
 
5385
 
int64_t Item_direct_ref::val_int()
5386
 
{
5387
 
  int64_t tmp=(*ref)->val_int();
5388
 
  null_value=(*ref)->null_value;
5389
 
  return tmp;
5390
 
}
5391
 
 
5392
 
 
5393
 
String *Item_direct_ref::val_str(String* tmp)
5394
 
{
5395
 
  tmp=(*ref)->val_str(tmp);
5396
 
  null_value=(*ref)->null_value;
5397
 
  return tmp;
5398
 
}
5399
 
 
5400
 
 
5401
 
my_decimal *Item_direct_ref::val_decimal(my_decimal *decimal_value)
5402
 
{
5403
 
  my_decimal *tmp= (*ref)->val_decimal(decimal_value);
5404
 
  null_value=(*ref)->null_value;
5405
 
  return tmp;
5406
 
}
5407
 
 
5408
 
 
5409
 
bool Item_direct_ref::val_bool()
5410
 
{
5411
 
  bool tmp= (*ref)->val_bool();
5412
 
  null_value=(*ref)->null_value;
5413
 
  return tmp;
5414
 
}
5415
 
 
5416
 
 
5417
 
bool Item_direct_ref::is_null()
5418
 
{
5419
 
  return (*ref)->is_null();
5420
 
}
5421
 
 
5422
 
 
5423
 
bool Item_direct_ref::get_date(DRIZZLE_TIME *ltime,uint fuzzydate)
5424
 
{
5425
 
  return (null_value=(*ref)->get_date(ltime,fuzzydate));
5426
 
}
5427
 
 
5428
 
 
5429
 
/**
5430
 
  Prepare referenced field then call usual Item_direct_ref::fix_fields .
5431
 
 
5432
 
  @param thd         thread handler
5433
 
  @param reference   reference on reference where this item stored
5434
 
 
5435
 
  @retval
5436
 
    false   OK
5437
 
  @retval
5438
 
    true    Error
5439
 
*/
5440
 
 
5441
 
bool Item_direct_view_ref::fix_fields(THD *thd, Item **reference)
5442
 
{
5443
 
  /* view fild reference must be defined */
5444
 
  assert(*ref);
5445
 
  /* (*ref)->check_cols() will be made in Item_direct_ref::fix_fields */
5446
 
  if (!(*ref)->fixed &&
5447
 
      ((*ref)->fix_fields(thd, ref)))
5448
 
    return true;
5449
 
  return Item_direct_ref::fix_fields(thd, reference);
5450
 
}
5451
 
 
5452
 
/*
5453
 
  Prepare referenced outer field then call usual Item_direct_ref::fix_fields
5454
 
 
5455
 
  SYNOPSIS
5456
 
    Item_outer_ref::fix_fields()
5457
 
    thd         thread handler
5458
 
    reference   reference on reference where this item stored
5459
 
 
5460
 
  RETURN
5461
 
    false   OK
5462
 
    true    Error
5463
 
*/
5464
 
 
5465
 
bool Item_outer_ref::fix_fields(THD *thd, Item **reference)
5466
 
{
5467
 
  bool err;
5468
 
  /* outer_ref->check_cols() will be made in Item_direct_ref::fix_fields */
5469
 
  if ((*ref) && !(*ref)->fixed && ((*ref)->fix_fields(thd, reference)))
5470
 
    return true;
5471
 
  err= Item_direct_ref::fix_fields(thd, reference);
5472
 
  if (!outer_ref)
5473
 
    outer_ref= *ref;
5474
 
  if ((*ref)->type() == Item::FIELD_ITEM)
5475
 
    table_name= ((Item_field*)outer_ref)->table_name;
5476
 
  return err;
5477
 
}
5478
 
 
5479
 
void Item_outer_ref::fix_after_pullout(st_select_lex *new_parent, Item **ref)
5480
 
{
5481
 
  if (depended_from == new_parent)
5482
 
  {
5483
 
    *ref= outer_ref;
5484
 
    outer_ref->fix_after_pullout(new_parent, ref);
5485
 
  }
5486
 
}
5487
 
 
5488
 
void Item_ref::fix_after_pullout(st_select_lex *new_parent,
5489
 
                                 Item **refptr __attribute__((unused)))
5490
 
{
5491
 
  if (depended_from == new_parent)
5492
 
  {
5493
 
    (*ref)->fix_after_pullout(new_parent, ref);
5494
 
    depended_from= NULL;
5495
 
  }
5496
 
}
5497
 
 
5498
 
/**
5499
 
  Compare two view column references for equality.
5500
 
 
5501
 
  A view column reference is considered equal to another column
5502
 
  reference if the second one is a view column and if both column
5503
 
  references resolve to the same item. It is assumed that both
5504
 
  items are of the same type.
5505
 
 
5506
 
  @param item        item to compare with
5507
 
  @param binary_cmp  make binary comparison
5508
 
 
5509
 
  @retval
5510
 
    true    Referenced item is equal to given item
5511
 
  @retval
5512
 
    false   otherwise
5513
 
*/
5514
 
 
5515
 
bool Item_direct_view_ref::eq(const Item *item,
5516
 
                              bool binary_cmp __attribute__((unused))) const
5517
 
{
5518
 
  if (item->type() == REF_ITEM)
5519
 
  {
5520
 
    Item_ref *item_ref= (Item_ref*) item;
5521
 
    if (item_ref->ref_type() == VIEW_REF)
5522
 
    {
5523
 
      Item *item_ref_ref= *(item_ref->ref);
5524
 
      return ((*ref)->real_item() == item_ref_ref->real_item());
5525
 
    }
5526
 
  }
5527
 
  return false;
5528
 
}
5529
 
 
5530
 
bool Item_default_value::eq(const Item *item, bool binary_cmp) const
5531
 
{
5532
 
  return item->type() == DEFAULT_VALUE_ITEM &&
5533
 
    ((Item_default_value *)item)->arg->eq(arg, binary_cmp);
5534
 
}
5535
 
 
5536
 
 
5537
 
bool Item_default_value::fix_fields(THD *thd,
5538
 
                                    Item **items __attribute__((unused)))
5539
 
{
5540
 
  Item *real_arg;
5541
 
  Item_field *field_arg;
5542
 
  Field *def_field;
5543
 
  assert(fixed == 0);
5544
 
 
5545
 
  if (!arg)
5546
 
  {
5547
 
    fixed= 1;
5548
 
    return false;
5549
 
  }
5550
 
  if (!arg->fixed && arg->fix_fields(thd, &arg))
5551
 
    goto error;
5552
 
 
5553
 
 
5554
 
  real_arg= arg->real_item();
5555
 
  if (real_arg->type() != FIELD_ITEM)
5556
 
  {
5557
 
    my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0), arg->name);
5558
 
    goto error;
5559
 
  }
5560
 
 
5561
 
  field_arg= (Item_field *)real_arg;
5562
 
  if (field_arg->field->flags & NO_DEFAULT_VALUE_FLAG)
5563
 
  {
5564
 
    my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0), field_arg->field->field_name);
5565
 
    goto error;
5566
 
  }
5567
 
  if (!(def_field= (Field*) sql_alloc(field_arg->field->size_of())))
5568
 
    goto error;
5569
 
  memcpy(def_field, field_arg->field, field_arg->field->size_of());
5570
 
  def_field->move_field_offset((my_ptrdiff_t)
5571
 
                               (def_field->table->s->default_values -
5572
 
                                def_field->table->record[0]));
5573
 
  set_field(def_field);
5574
 
  return false;
5575
 
 
5576
 
error:
5577
 
  context->process_error(thd);
5578
 
  return true;
5579
 
}
5580
 
 
5581
 
 
5582
 
void Item_default_value::print(String *str, enum_query_type query_type)
5583
 
{
5584
 
  if (!arg)
5585
 
  {
5586
 
    str->append(STRING_WITH_LEN("default"));
5587
 
    return;
5588
 
  }
5589
 
  str->append(STRING_WITH_LEN("default("));
5590
 
  arg->print(str, query_type);
5591
 
  str->append(')');
5592
 
}
5593
 
 
5594
 
 
5595
 
int Item_default_value::save_in_field(Field *field_arg, bool no_conversions)
5596
 
{
5597
 
  if (!arg)
5598
 
  {
5599
 
    if (field_arg->flags & NO_DEFAULT_VALUE_FLAG)
5600
 
    {
5601
 
      if (field_arg->reset())
5602
 
      {
5603
 
        my_message(ER_CANT_CREATE_GEOMETRY_OBJECT,
5604
 
                   ER(ER_CANT_CREATE_GEOMETRY_OBJECT), MYF(0));
5605
 
        return -1;
5606
 
      }
5607
 
 
5608
 
      {
5609
 
        push_warning_printf(field_arg->table->in_use,
5610
 
                            DRIZZLE_ERROR::WARN_LEVEL_WARN,
5611
 
                            ER_NO_DEFAULT_FOR_FIELD,
5612
 
                            ER(ER_NO_DEFAULT_FOR_FIELD),
5613
 
                            field_arg->field_name);
5614
 
      }
5615
 
      return 1;
5616
 
    }
5617
 
    field_arg->set_default();
5618
 
    return 0;
5619
 
  }
5620
 
  return Item_field::save_in_field(field_arg, no_conversions);
5621
 
}
5622
 
 
5623
 
 
5624
 
/**
5625
 
  This method like the walk method traverses the item tree, but at the
5626
 
  same time it can replace some nodes in the tree.
5627
 
*/ 
5628
 
 
5629
 
Item *Item_default_value::transform(Item_transformer transformer, uchar *args)
5630
 
{
5631
 
  Item *new_item= arg->transform(transformer, args);
5632
 
  if (!new_item)
5633
 
    return 0;
5634
 
 
5635
 
  /*
5636
 
    THD::change_item_tree() should be called only if the tree was
5637
 
    really transformed, i.e. when a new item has been created.
5638
 
    Otherwise we'll be allocating a lot of unnecessary memory for
5639
 
    change records at each execution.
5640
 
  */
5641
 
  if (arg != new_item)
5642
 
    current_thd->change_item_tree(&arg, new_item);
5643
 
  return (this->*transformer)(args);
5644
 
}
5645
 
 
5646
 
 
5647
 
bool Item_insert_value::eq(const Item *item, bool binary_cmp) const
5648
 
{
5649
 
  return item->type() == INSERT_VALUE_ITEM &&
5650
 
    ((Item_default_value *)item)->arg->eq(arg, binary_cmp);
5651
 
}
5652
 
 
5653
 
 
5654
 
bool Item_insert_value::fix_fields(THD *thd,
5655
 
                                   Item **items __attribute__((unused)))
5656
 
{
5657
 
  assert(fixed == 0);
5658
 
  /* We should only check that arg is in first table */
5659
 
  if (!arg->fixed)
5660
 
  {
5661
 
    bool res;
5662
 
    TABLE_LIST *orig_next_table= context->last_name_resolution_table;
5663
 
    context->last_name_resolution_table= context->first_name_resolution_table;
5664
 
    res= arg->fix_fields(thd, &arg);
5665
 
    context->last_name_resolution_table= orig_next_table;
5666
 
    if (res)
5667
 
      return true;
5668
 
  }
5669
 
 
5670
 
  if (arg->type() == REF_ITEM)
5671
 
  {
5672
 
    Item_ref *ref= (Item_ref *)arg;
5673
 
    if (ref->ref[0]->type() != FIELD_ITEM)
5674
 
    {
5675
 
      my_error(ER_BAD_FIELD_ERROR, MYF(0), "", "VALUES() function");
5676
 
      return true;
5677
 
    }
5678
 
    arg= ref->ref[0];
5679
 
  }
5680
 
  /*
5681
 
    According to our SQL grammar, VALUES() function can reference
5682
 
    only to a column.
5683
 
  */
5684
 
  assert(arg->type() == FIELD_ITEM);
5685
 
 
5686
 
  Item_field *field_arg= (Item_field *)arg;
5687
 
 
5688
 
  if (field_arg->field->table->insert_values)
5689
 
  {
5690
 
    Field *def_field= (Field*) sql_alloc(field_arg->field->size_of());
5691
 
    if (!def_field)
5692
 
      return true;
5693
 
    memcpy(def_field, field_arg->field, field_arg->field->size_of());
5694
 
    def_field->move_field_offset((my_ptrdiff_t)
5695
 
                                 (def_field->table->insert_values -
5696
 
                                  def_field->table->record[0]));
5697
 
    set_field(def_field);
5698
 
  }
5699
 
  else
5700
 
  {
5701
 
    Field *tmp_field= field_arg->field;
5702
 
    /* charset doesn't matter here, it's to avoid sigsegv only */
5703
 
    tmp_field= new Field_null(0, 0, Field::NONE, field_arg->field->field_name,
5704
 
                          &my_charset_bin);
5705
 
    if (tmp_field)
5706
 
    {
5707
 
      tmp_field->init(field_arg->field->table);
5708
 
      set_field(tmp_field);
5709
 
    }
5710
 
  }
5711
 
  return false;
5712
 
}
5713
 
 
5714
 
void Item_insert_value::print(String *str, enum_query_type query_type)
5715
 
{
5716
 
  str->append(STRING_WITH_LEN("values("));
5717
 
  arg->print(str, query_type);
5718
 
  str->append(')');
5719
 
}
5720
 
 
5721
 
 
5722
1335
Item_result item_cmp_type(Item_result a,Item_result b)
5723
1336
{
5724
1337
  if (a == STRING_RESULT && b == STRING_RESULT)
5733
1346
  return REAL_RESULT;
5734
1347
}
5735
1348
 
5736
 
 
5737
 
void resolve_const_item(THD *thd, Item **ref, Item *comp_item)
 
1349
void resolve_const_item(Session *session, Item **ref, Item *comp_item)
5738
1350
{
5739
1351
  Item *item= *ref;
5740
1352
  Item *new_item= NULL;
5741
1353
  if (item->basic_const_item())
5742
 
    return;                                     // Can't be better
 
1354
    return; /* Can't be better */
5743
1355
  Item_result res_type=item_cmp_type(comp_item->result_type(),
5744
1356
                                     item->result_type());
5745
 
  char *name=item->name;                        // Alloced by sql_alloc
 
1357
  char *name=item->name; /* Alloced by sql_alloc */
5746
1358
 
5747
1359
  switch (res_type) {
5748
1360
  case STRING_RESULT:
5754
1366
      new_item= new Item_null(name);
5755
1367
    else
5756
1368
    {
5757
 
      uint length= result->length();
 
1369
      uint32_t length= result->length();
5758
1370
      char *tmp_str= sql_strmake(result->ptr(), length);
5759
1371
      new_item= new Item_string(name, tmp_str, length, result->charset());
5760
1372
    }
5763
1375
  case INT_RESULT:
5764
1376
  {
5765
1377
    int64_t result=item->val_int();
5766
 
    uint length=item->max_length;
 
1378
    uint32_t length=item->max_length;
5767
1379
    bool null_value=item->null_value;
5768
1380
    new_item= (null_value ? (Item*) new Item_null(name) :
5769
1381
               (Item*) new Item_int(name, result, length));
5782
1394
    */
5783
1395
    Item_row *item_row= (Item_row*) item;
5784
1396
    Item_row *comp_item_row= (Item_row*) comp_item;
5785
 
    uint col;
 
1397
    uint32_t col;
5786
1398
    new_item= 0;
5787
1399
    /*
5788
1400
      If item and comp_item are both Item_rows and have same number of cols
5794
1406
    assert(item_row->cols() == comp_item_row->cols());
5795
1407
    col= item_row->cols();
5796
1408
    while (col-- > 0)
5797
 
      resolve_const_item(thd, item_row->addr(col),
 
1409
      resolve_const_item(session, item_row->addr(col),
5798
1410
                         comp_item_row->element_index(col));
5799
1411
    break;
5800
1412
  }
5802
1414
  case REAL_RESULT:
5803
1415
  {                                             // It must REAL_RESULT
5804
1416
    double result= item->val_real();
5805
 
    uint length=item->max_length,decimals=item->decimals;
 
1417
    uint32_t length=item->max_length,decimals=item->decimals;
5806
1418
    bool null_value=item->null_value;
5807
1419
    new_item= (null_value ? (Item*) new Item_null(name) : (Item*)
5808
1420
               new Item_float(name, result, decimals, length));
5812
1424
  {
5813
1425
    my_decimal decimal_value;
5814
1426
    my_decimal *result= item->val_decimal(&decimal_value);
5815
 
    uint length= item->max_length, decimals= item->decimals;
 
1427
    uint32_t length= item->max_length, decimals= item->decimals;
5816
1428
    bool null_value= item->null_value;
5817
1429
    new_item= (null_value ?
5818
1430
               (Item*) new Item_null(name) :
5823
1435
    assert(0);
5824
1436
  }
5825
1437
  if (new_item)
5826
 
    thd->change_item_tree(ref, new_item);
 
1438
    session->change_item_tree(ref, new_item);
5827
1439
}
5828
1440
 
5829
 
/**
5830
 
  Return true if the value stored in the field is equal to the const
5831
 
  item.
5832
 
 
5833
 
  We need to use this on the range optimizer because in some cases
5834
 
  we can't store the value in the field without some precision/character loss.
5835
 
*/
5836
 
 
5837
1441
bool field_is_equal_to_item(Field *field,Item *item)
5838
1442
{
5839
1443
 
5869
1473
  return result == field->val_real();
5870
1474
}
5871
1475
 
5872
 
Item_cache* Item_cache::get_cache(const Item *item)
 
1476
void dummy_error_processor(Session *, void *)
 
1477
{}
 
1478
 
 
1479
/**
 
1480
  Create field for temporary table using type of given item.
 
1481
 
 
1482
  @param session                   Thread handler
 
1483
  @param item                  Item to create a field for
 
1484
  @param table                 Temporary table
 
1485
  @param copy_func             If set and item is a function, store copy of
 
1486
                               item in this array
 
1487
  @param modify_item           1 if item->result_field should point to new
 
1488
                               item. This is relevent for how fill_record()
 
1489
                               is going to work:
 
1490
                               If modify_item is 1 then fill_record() will
 
1491
                               update the record in the original table.
 
1492
                               If modify_item is 0 then fill_record() will
 
1493
                               update the temporary table
 
1494
  @param convert_blob_length   If >0 create a varstring(convert_blob_length)
 
1495
                               field instead of blob.
 
1496
 
 
1497
  @retval
 
1498
    0  on error
 
1499
  @retval
 
1500
    new_created field
 
1501
*/
 
1502
static Field *create_tmp_field_from_item(Session *,
 
1503
                                         Item *item, Table *table,
 
1504
                                         Item ***copy_func, bool modify_item,
 
1505
                                         uint32_t convert_blob_length)
5873
1506
{
 
1507
  bool maybe_null= item->maybe_null;
 
1508
  Field *new_field;
 
1509
 
5874
1510
  switch (item->result_type()) {
 
1511
  case REAL_RESULT:
 
1512
    new_field= new Field_double(item->max_length, maybe_null,
 
1513
                                item->name, item->decimals, true);
 
1514
    break;
5875
1515
  case INT_RESULT:
5876
 
    return new Item_cache_int();
5877
 
  case REAL_RESULT:
5878
 
    return new Item_cache_real();
 
1516
    /*
 
1517
      Select an integer type with the minimal fit precision.
 
1518
      MY_INT32_NUM_DECIMAL_DIGITS is sign inclusive, don't consider the sign.
 
1519
      Values with MY_INT32_NUM_DECIMAL_DIGITS digits may or may not fit into
 
1520
      Field_long : make them Field_int64_t.
 
1521
    */
 
1522
    if (item->max_length >= (MY_INT32_NUM_DECIMAL_DIGITS - 1))
 
1523
      new_field=new Field_int64_t(item->max_length, maybe_null,
 
1524
                                   item->name, item->unsigned_flag);
 
1525
    else
 
1526
      new_field=new Field_long(item->max_length, maybe_null,
 
1527
                               item->name, item->unsigned_flag);
 
1528
    break;
 
1529
  case STRING_RESULT:
 
1530
    assert(item->collation.collation);
 
1531
 
 
1532
    enum enum_field_types type;
 
1533
    /*
 
1534
      DATE/TIME fields have STRING_RESULT result type.
 
1535
      To preserve type they needed to be handled separately.
 
1536
    */
 
1537
    if ((type= item->field_type()) == DRIZZLE_TYPE_DATETIME ||
 
1538
        type == DRIZZLE_TYPE_DATE ||
 
1539
        type == DRIZZLE_TYPE_TIMESTAMP)
 
1540
      new_field= item->tmp_table_field_from_field_type(table, 1);
 
1541
    /*
 
1542
      Make sure that the blob fits into a Field_varstring which has
 
1543
      2-byte lenght.
 
1544
    */
 
1545
    else if (item->max_length/item->collation.collation->mbmaxlen > 255 &&
 
1546
             convert_blob_length <= Field_varstring::MAX_SIZE &&
 
1547
             convert_blob_length)
 
1548
      new_field= new Field_varstring(convert_blob_length, maybe_null,
 
1549
                                     item->name, table->s,
 
1550
                                     item->collation.collation);
 
1551
    else
 
1552
      new_field= item->make_string_field(table);
 
1553
    new_field->set_derivation(item->collation.derivation);
 
1554
    break;
5879
1555
  case DECIMAL_RESULT:
5880
 
    return new Item_cache_decimal();
5881
 
  case STRING_RESULT:
5882
 
    return new Item_cache_str(item);
 
1556
  {
 
1557
    uint8_t dec= item->decimals;
 
1558
    uint8_t intg= ((Item_decimal *) item)->decimal_precision() - dec;
 
1559
    uint32_t len= item->max_length;
 
1560
 
 
1561
    /*
 
1562
      Trying to put too many digits overall in a DECIMAL(prec,dec)
 
1563
      will always throw a warning. We must limit dec to
 
1564
      DECIMAL_MAX_SCALE however to prevent an assert() later.
 
1565
    */
 
1566
 
 
1567
    if (dec > 0)
 
1568
    {
 
1569
      signed int overflow;
 
1570
 
 
1571
      dec= min(dec, (uint8_t)DECIMAL_MAX_SCALE);
 
1572
 
 
1573
      /*
 
1574
        If the value still overflows the field with the corrected dec,
 
1575
        we'll throw out decimals rather than integers. This is still
 
1576
        bad and of course throws a truncation warning.
 
1577
        +1: for decimal point
 
1578
      */
 
1579
 
 
1580
      overflow= my_decimal_precision_to_length(intg + dec, dec,
 
1581
                                               item->unsigned_flag) - len;
 
1582
 
 
1583
      if (overflow > 0)
 
1584
        dec= max(0, dec - overflow);            // too long, discard fract
 
1585
      else
 
1586
        len-= item->decimals - dec;             // corrected value fits
 
1587
    }
 
1588
 
 
1589
    new_field= new Field_decimal(len,
 
1590
                                 maybe_null,
 
1591
                                 item->name,
 
1592
                                 dec,
 
1593
                                 item->unsigned_flag);
 
1594
    break;
 
1595
  }
5883
1596
  case ROW_RESULT:
5884
 
    return new Item_cache_row();
5885
1597
  default:
5886
 
    // should never be in real life
 
1598
    // This case should never be choosen
5887
1599
    assert(0);
5888
 
    return 0;
5889
 
  }
5890
 
}
5891
 
 
5892
 
 
5893
 
void Item_cache::print(String *str, enum_query_type query_type)
5894
 
{
5895
 
  str->append(STRING_WITH_LEN("<cache>("));
5896
 
  if (example)
5897
 
    example->print(str, query_type);
5898
 
  else
5899
 
    Item::print(str, query_type);
5900
 
  str->append(')');
5901
 
}
5902
 
 
5903
 
 
5904
 
void Item_cache_int::store(Item *item)
5905
 
{
5906
 
  value= item->val_int_result();
5907
 
  null_value= item->null_value;
5908
 
  unsigned_flag= item->unsigned_flag;
5909
 
}
5910
 
 
5911
 
 
5912
 
void Item_cache_int::store(Item *item, int64_t val_arg)
5913
 
{
5914
 
  value= val_arg;
5915
 
  null_value= item->null_value;
5916
 
  unsigned_flag= item->unsigned_flag;
5917
 
}
5918
 
 
5919
 
 
5920
 
String *Item_cache_int::val_str(String *str)
5921
 
{
5922
 
  assert(fixed == 1);
5923
 
  str->set(value, default_charset());
5924
 
  return str;
5925
 
}
5926
 
 
5927
 
 
5928
 
my_decimal *Item_cache_int::val_decimal(my_decimal *decimal_val)
5929
 
{
5930
 
  assert(fixed == 1);
5931
 
  int2my_decimal(E_DEC_FATAL_ERROR, value, unsigned_flag, decimal_val);
5932
 
  return decimal_val;
5933
 
}
5934
 
 
5935
 
 
5936
 
void Item_cache_real::store(Item *item)
5937
 
{
5938
 
  value= item->val_result();
5939
 
  null_value= item->null_value;
5940
 
}
5941
 
 
5942
 
 
5943
 
int64_t Item_cache_real::val_int()
5944
 
{
5945
 
  assert(fixed == 1);
5946
 
  return (int64_t) rint(value);
5947
 
}
5948
 
 
5949
 
 
5950
 
String* Item_cache_real::val_str(String *str)
5951
 
{
5952
 
  assert(fixed == 1);
5953
 
  str->set_real(value, decimals, default_charset());
5954
 
  return str;
5955
 
}
5956
 
 
5957
 
 
5958
 
my_decimal *Item_cache_real::val_decimal(my_decimal *decimal_val)
5959
 
{
5960
 
  assert(fixed == 1);
5961
 
  double2my_decimal(E_DEC_FATAL_ERROR, value, decimal_val);
5962
 
  return decimal_val;
5963
 
}
5964
 
 
5965
 
 
5966
 
void Item_cache_decimal::store(Item *item)
5967
 
{
5968
 
  my_decimal *val= item->val_decimal_result(&decimal_value);
5969
 
  if (!(null_value= item->null_value) && val != &decimal_value)
5970
 
    my_decimal2decimal(val, &decimal_value);
5971
 
}
5972
 
 
5973
 
double Item_cache_decimal::val_real()
5974
 
{
5975
 
  assert(fixed);
5976
 
  double res;
5977
 
  my_decimal2double(E_DEC_FATAL_ERROR, &decimal_value, &res);
5978
 
  return res;
5979
 
}
5980
 
 
5981
 
int64_t Item_cache_decimal::val_int()
5982
 
{
5983
 
  assert(fixed);
5984
 
  int64_t res;
5985
 
  my_decimal2int(E_DEC_FATAL_ERROR, &decimal_value, unsigned_flag, &res);
5986
 
  return res;
5987
 
}
5988
 
 
5989
 
String* Item_cache_decimal::val_str(String *str)
5990
 
{
5991
 
  assert(fixed);
5992
 
  my_decimal_round(E_DEC_FATAL_ERROR, &decimal_value, decimals, false,
5993
 
                   &decimal_value);
5994
 
  my_decimal2string(E_DEC_FATAL_ERROR, &decimal_value, 0, 0, 0, str);
5995
 
  return str;
5996
 
}
5997
 
 
5998
 
my_decimal *Item_cache_decimal::val_decimal(my_decimal *val __attribute__((unused)))
5999
 
{
6000
 
  assert(fixed);
6001
 
  return &decimal_value;
6002
 
}
6003
 
 
6004
 
 
6005
 
void Item_cache_str::store(Item *item)
6006
 
{
6007
 
  value_buff.set(buffer, sizeof(buffer), item->collation.collation);
6008
 
  value= item->str_result(&value_buff);
6009
 
  if ((null_value= item->null_value))
6010
 
    value= 0;
6011
 
  else if (value != &value_buff)
6012
 
  {
6013
 
    /*
6014
 
      We copy string value to avoid changing value if 'item' is table field
6015
 
      in queries like following (where t1.c is varchar):
6016
 
      select a, 
6017
 
             (select a,b,c from t1 where t1.a=t2.a) = ROW(a,2,'a'),
6018
 
             (select c from t1 where a=t2.a)
6019
 
        from t2;
6020
 
    */
6021
 
    value_buff.copy(*value);
6022
 
    value= &value_buff;
6023
 
  }
6024
 
}
6025
 
 
6026
 
double Item_cache_str::val_real()
6027
 
{
6028
 
  assert(fixed == 1);
6029
 
  int err_not_used;
6030
 
  char *end_not_used;
6031
 
  if (value)
6032
 
    return my_strntod(value->charset(), (char*) value->ptr(),
6033
 
                      value->length(), &end_not_used, &err_not_used);
6034
 
  return (double) 0;
6035
 
}
6036
 
 
6037
 
 
6038
 
int64_t Item_cache_str::val_int()
6039
 
{
6040
 
  assert(fixed == 1);
6041
 
  int err;
6042
 
  if (value)
6043
 
    return my_strntoll(value->charset(), value->ptr(),
6044
 
                       value->length(), 10, (char**) 0, &err);
6045
 
  else
6046
 
    return (int64_t)0;
6047
 
}
6048
 
 
6049
 
my_decimal *Item_cache_str::val_decimal(my_decimal *decimal_val)
6050
 
{
6051
 
  assert(fixed == 1);
6052
 
  if (value)
6053
 
    string2my_decimal(E_DEC_FATAL_ERROR, value, decimal_val);
6054
 
  else
6055
 
    decimal_val= 0;
6056
 
  return decimal_val;
6057
 
}
6058
 
 
6059
 
 
6060
 
int Item_cache_str::save_in_field(Field *field, bool no_conversions)
6061
 
{
6062
 
  int res= Item_cache::save_in_field(field, no_conversions);
6063
 
 
6064
 
  return res;
6065
 
}
6066
 
 
6067
 
 
6068
 
bool Item_cache_row::allocate(uint num)
6069
 
{
6070
 
  item_count= num;
6071
 
  THD *thd= current_thd;
6072
 
  return (!(values= 
6073
 
            (Item_cache **) thd->calloc(sizeof(Item_cache *)*item_count)));
6074
 
}
6075
 
 
6076
 
 
6077
 
bool Item_cache_row::setup(Item * item)
6078
 
{
6079
 
  example= item;
6080
 
  if (!values && allocate(item->cols()))
6081
 
    return 1;
6082
 
  for (uint i= 0; i < item_count; i++)
6083
 
  {
6084
 
    Item *el= item->element_index(i);
6085
 
    Item_cache *tmp;
6086
 
    if (!(tmp= values[i]= Item_cache::get_cache(el)))
6087
 
      return 1;
6088
 
    tmp->setup(el);
6089
 
  }
6090
 
  return 0;
6091
 
}
6092
 
 
6093
 
 
6094
 
void Item_cache_row::store(Item * item)
6095
 
{
6096
 
  null_value= 0;
6097
 
  item->bring_value();
6098
 
  for (uint i= 0; i < item_count; i++)
6099
 
  {
6100
 
    values[i]->store(item->element_index(i));
6101
 
    null_value|= values[i]->null_value;
6102
 
  }
6103
 
}
6104
 
 
6105
 
 
6106
 
void Item_cache_row::illegal_method_call(const char *method __attribute__((unused)))
6107
 
{
6108
 
  assert(0);
6109
 
  my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
6110
 
  return;
6111
 
}
6112
 
 
6113
 
 
6114
 
bool Item_cache_row::check_cols(uint c)
6115
 
{
6116
 
  if (c != item_count)
6117
 
  {
6118
 
    my_error(ER_OPERAND_COLUMNS, MYF(0), c);
6119
 
    return 1;
6120
 
  }
6121
 
  return 0;
6122
 
}
6123
 
 
6124
 
 
6125
 
bool Item_cache_row::null_inside()
6126
 
{
6127
 
  for (uint i= 0; i < item_count; i++)
6128
 
  {
6129
 
    if (values[i]->cols() > 1)
6130
 
    {
6131
 
      if (values[i]->null_inside())
6132
 
        return 1;
6133
 
    }
6134
 
    else
6135
 
    {
6136
 
      values[i]->update_null_value();
6137
 
      if (values[i]->null_value)
6138
 
        return 1;
6139
 
    }
6140
 
  }
6141
 
  return 0;
6142
 
}
6143
 
 
6144
 
 
6145
 
void Item_cache_row::bring_value()
6146
 
{
6147
 
  for (uint i= 0; i < item_count; i++)
6148
 
    values[i]->bring_value();
6149
 
  return;
6150
 
}
6151
 
 
6152
 
 
6153
 
Item_type_holder::Item_type_holder(THD *thd, Item *item)
6154
 
  :Item(thd, item), enum_set_typelib(0), fld_type(get_real_type(item))
6155
 
{
6156
 
  assert(item->fixed);
6157
 
  maybe_null= item->maybe_null;
6158
 
  collation.set(item->collation);
6159
 
  get_full_info(item);
6160
 
  /* fix variable decimals which always is NOT_FIXED_DEC */
6161
 
  if (Field::result_merge_type(fld_type) == INT_RESULT)
6162
 
    decimals= 0;
6163
 
  prev_decimal_int_part= item->decimal_int_part();
6164
 
}
6165
 
 
6166
 
 
6167
 
/**
6168
 
  Return expression type of Item_type_holder.
6169
 
 
6170
 
  @return
6171
 
    Item_result (type of internal MySQL expression result)
6172
 
*/
6173
 
 
6174
 
Item_result Item_type_holder::result_type() const
6175
 
{
6176
 
  return Field::result_merge_type(fld_type);
6177
 
}
6178
 
 
6179
 
 
6180
 
/**
6181
 
  Find real field type of item.
6182
 
 
6183
 
  @return
6184
 
    type of field which should be created to store item value
6185
 
*/
6186
 
 
6187
 
enum_field_types Item_type_holder::get_real_type(Item *item)
6188
 
{
6189
 
  switch(item->type())
6190
 
  {
6191
 
  case FIELD_ITEM:
6192
 
  {
6193
 
    /*
6194
 
      Item_fields::field_type ask Field_type() but sometimes field return
6195
 
      a different type, like for enum/set, so we need to ask real type.
6196
 
    */
6197
 
    Field *field= ((Item_field *) item)->field;
6198
 
    enum_field_types type= field->real_type();
6199
 
    if (field->is_created_from_null_item)
6200
 
      return DRIZZLE_TYPE_NULL;
6201
 
    return type;
6202
 
  }
6203
 
  case SUM_FUNC_ITEM:
6204
 
  {
6205
 
    /*
6206
 
      Argument of aggregate function sometimes should be asked about field
6207
 
      type
6208
 
    */
6209
 
    Item_sum *item_sum= (Item_sum *) item;
6210
 
    if (item_sum->keep_field_type())
6211
 
      return get_real_type(item_sum->args[0]);
6212
 
    break;
6213
 
  }
6214
 
  case FUNC_ITEM:
6215
 
    if (((Item_func *) item)->functype() == Item_func::GUSERVAR_FUNC)
6216
 
    {
6217
 
      /*
6218
 
        There are work around of problem with changing variable type on the
6219
 
        fly and variable always report "string" as field type to get
6220
 
        acceptable information for client in send_field, so we make field
6221
 
        type from expression type.
6222
 
      */
6223
 
      switch (item->result_type()) {
6224
 
      case STRING_RESULT:
6225
 
        return DRIZZLE_TYPE_VARCHAR;
6226
 
      case INT_RESULT:
6227
 
        return DRIZZLE_TYPE_LONGLONG;
6228
 
      case REAL_RESULT:
6229
 
        return DRIZZLE_TYPE_DOUBLE;
6230
 
      case DECIMAL_RESULT:
6231
 
        return DRIZZLE_TYPE_NEWDECIMAL;
6232
 
      case ROW_RESULT:
6233
 
      default:
6234
 
        assert(0);
6235
 
        return DRIZZLE_TYPE_VARCHAR;
6236
 
      }
6237
 
    }
6238
 
    break;
6239
 
  default:
6240
 
    break;
6241
 
  }
6242
 
  return item->field_type();
6243
 
}
6244
 
 
6245
 
/**
6246
 
  Find field type which can carry current Item_type_holder type and
6247
 
  type of given Item.
6248
 
 
6249
 
  @param thd     thread handler
6250
 
  @param item    given item to join its parameters with this item ones
6251
 
 
6252
 
  @retval
6253
 
    true   error - types are incompatible
6254
 
  @retval
6255
 
    false  OK
6256
 
*/
6257
 
 
6258
 
bool Item_type_holder::join_types(THD *thd __attribute__((unused)),
6259
 
                                  Item *item)
6260
 
{
6261
 
  uint max_length_orig= max_length;
6262
 
  uint decimals_orig= decimals;
6263
 
  fld_type= Field::field_type_merge(fld_type, get_real_type(item));
6264
 
  {
6265
 
    int item_decimals= item->decimals;
6266
 
    /* fix variable decimals which always is NOT_FIXED_DEC */
6267
 
    if (Field::result_merge_type(fld_type) == INT_RESULT)
6268
 
      item_decimals= 0;
6269
 
    decimals= max((int)decimals, item_decimals);
6270
 
  }
6271
 
  if (Field::result_merge_type(fld_type) == DECIMAL_RESULT)
6272
 
  {
6273
 
    decimals= min((int)max(decimals, item->decimals), DECIMAL_MAX_SCALE);
6274
 
    int precision= min(max(prev_decimal_int_part, item->decimal_int_part())
6275
 
                       + decimals, DECIMAL_MAX_PRECISION);
6276
 
    unsigned_flag&= item->unsigned_flag;
6277
 
    max_length= my_decimal_precision_to_length(precision, decimals,
6278
 
                                               unsigned_flag);
6279
 
  }
6280
 
 
6281
 
  switch (Field::result_merge_type(fld_type))
6282
 
  {
6283
 
  case STRING_RESULT:
6284
 
  {
6285
 
    const char *old_cs, *old_derivation;
6286
 
    uint32_t old_max_chars= max_length / collation.collation->mbmaxlen;
6287
 
    old_cs= collation.collation->name;
6288
 
    old_derivation= collation.derivation_name();
6289
 
    if (collation.aggregate(item->collation, MY_COLL_ALLOW_CONV))
6290
 
    {
6291
 
      my_error(ER_CANT_AGGREGATE_2COLLATIONS, MYF(0),
6292
 
               old_cs, old_derivation,
6293
 
               item->collation.collation->name,
6294
 
               item->collation.derivation_name(),
6295
 
               "UNION");
6296
 
      return(true);
6297
 
    }
6298
 
    /*
6299
 
      To figure out max_length, we have to take into account possible
6300
 
      expansion of the size of the values because of character set
6301
 
      conversions.
6302
 
     */
6303
 
    if (collation.collation != &my_charset_bin)
6304
 
    {
6305
 
      max_length= max(old_max_chars * collation.collation->mbmaxlen,
6306
 
                      display_length(item) /
6307
 
                      item->collation.collation->mbmaxlen *
6308
 
                      collation.collation->mbmaxlen);
6309
 
    }
6310
 
    else
6311
 
      set_if_bigger(max_length, display_length(item));
6312
 
    break;
6313
 
  }
6314
 
  case REAL_RESULT:
6315
 
  {
6316
 
    if (decimals != NOT_FIXED_DEC)
6317
 
    {
6318
 
      int delta1= max_length_orig - decimals_orig;
6319
 
      int delta2= item->max_length - item->decimals;
6320
 
      max_length= max(delta1, delta2) + decimals;
6321
 
      if (fld_type == DRIZZLE_TYPE_DOUBLE && max_length > DBL_DIG + 2) 
6322
 
      {
6323
 
        max_length= DBL_DIG + 7;
6324
 
        decimals= NOT_FIXED_DEC;
6325
 
      }
6326
 
    }
6327
 
    else
6328
 
      max_length= DBL_DIG+7;
6329
 
    break;
6330
 
  }
6331
 
  default:
6332
 
    max_length= max(max_length, display_length(item));
6333
 
  };
6334
 
  maybe_null|= item->maybe_null;
6335
 
  get_full_info(item);
6336
 
 
6337
 
  /* Remember decimal integer part to be used in DECIMAL_RESULT handleng */
6338
 
  prev_decimal_int_part= decimal_int_part();
6339
 
  return(false);
6340
 
}
6341
 
 
6342
 
/**
6343
 
  Calculate lenth for merging result for given Item type.
6344
 
 
6345
 
  @param item  Item for length detection
6346
 
 
6347
 
  @return
6348
 
    length
6349
 
*/
6350
 
 
6351
 
uint32_t Item_type_holder::display_length(Item *item)
6352
 
{
6353
 
  if (item->type() == Item::FIELD_ITEM)
6354
 
    return ((Item_field *)item)->max_disp_length();
6355
 
 
6356
 
  switch (item->field_type())
6357
 
  {
6358
 
  case DRIZZLE_TYPE_TIMESTAMP:
6359
 
  case DRIZZLE_TYPE_TIME:
6360
 
  case DRIZZLE_TYPE_DATETIME:
6361
 
  case DRIZZLE_TYPE_NEWDATE:
6362
 
  case DRIZZLE_TYPE_VARCHAR:
6363
 
  case DRIZZLE_TYPE_NEWDECIMAL:
6364
 
  case DRIZZLE_TYPE_ENUM:
6365
 
  case DRIZZLE_TYPE_BLOB:
6366
 
  case DRIZZLE_TYPE_TINY:
6367
 
    return 4;
6368
 
  case DRIZZLE_TYPE_SHORT:
6369
 
    return 6;
6370
 
  case DRIZZLE_TYPE_LONG:
6371
 
    return MY_INT32_NUM_DECIMAL_DIGITS;
6372
 
  case DRIZZLE_TYPE_DOUBLE:
6373
 
    return 53;
6374
 
  case DRIZZLE_TYPE_NULL:
6375
 
    return 0;
6376
 
  case DRIZZLE_TYPE_LONGLONG:
6377
 
    return 20;
6378
 
  default:
6379
 
    assert(0); // we should never go there
6380
 
    return 0;
6381
 
  }
6382
 
}
6383
 
 
6384
 
 
6385
 
/**
6386
 
  Make temporary table field according collected information about type
6387
 
  of UNION result.
6388
 
 
6389
 
  @param table  temporary table for which we create fields
6390
 
 
6391
 
  @return
6392
 
    created field
6393
 
*/
6394
 
 
6395
 
Field *Item_type_holder::make_field_by_type(TABLE *table)
6396
 
{
6397
 
  /*
6398
 
    The field functions defines a field to be not null if null_ptr is not 0
6399
 
  */
6400
 
  uchar *null_ptr= maybe_null ? (uchar*) "" : 0;
6401
 
  Field *field;
6402
 
 
6403
 
  switch (fld_type) {
6404
 
  case DRIZZLE_TYPE_ENUM:
6405
 
    assert(enum_set_typelib);
6406
 
    field= new Field_enum((uchar *) 0, max_length, null_ptr, 0,
6407
 
                          Field::NONE, name,
6408
 
                          get_enum_pack_length(enum_set_typelib->count),
6409
 
                          enum_set_typelib, collation.collation);
6410
 
    if (field)
6411
 
      field->init(table);
6412
 
    return field;
6413
 
  case DRIZZLE_TYPE_NULL:
6414
 
    return make_string_field(table);
6415
 
  default:
6416
 
    break;
6417
 
  }
6418
 
  return tmp_table_field_from_field_type(table, 0);
6419
 
}
6420
 
 
6421
 
 
6422
 
/**
6423
 
  Get full information from Item about enum/set fields to be able to create
6424
 
  them later.
6425
 
 
6426
 
  @param item    Item for information collection
6427
 
*/
6428
 
void Item_type_holder::get_full_info(Item *item)
6429
 
{
6430
 
  if (fld_type == DRIZZLE_TYPE_ENUM)
6431
 
  {
6432
 
    if (item->type() == Item::SUM_FUNC_ITEM &&
6433
 
        (((Item_sum*)item)->sum_func() == Item_sum::MAX_FUNC ||
6434
 
         ((Item_sum*)item)->sum_func() == Item_sum::MIN_FUNC))
6435
 
      item = ((Item_sum*)item)->args[0];
6436
 
    /*
6437
 
      We can have enum/set type after merging only if we have one enum|set
6438
 
      field (or MIN|MAX(enum|set field)) and number of NULL fields
6439
 
    */
6440
 
    assert((enum_set_typelib &&
6441
 
                 get_real_type(item) == DRIZZLE_TYPE_NULL) ||
6442
 
                (!enum_set_typelib &&
6443
 
                 item->type() == Item::FIELD_ITEM &&
6444
 
                 (get_real_type(item) == DRIZZLE_TYPE_ENUM) &&
6445
 
                 ((Field_enum*)((Item_field *) item)->field)->typelib));
6446
 
    if (!enum_set_typelib)
6447
 
    {
6448
 
      enum_set_typelib= ((Field_enum*)((Item_field *) item)->field)->typelib;
6449
 
    }
6450
 
  }
6451
 
}
6452
 
 
6453
 
 
6454
 
double Item_type_holder::val_real()
6455
 
{
6456
 
  assert(0); // should never be called
6457
 
  return 0.0;
6458
 
}
6459
 
 
6460
 
 
6461
 
int64_t Item_type_holder::val_int()
6462
 
{
6463
 
  assert(0); // should never be called
6464
 
  return 0;
6465
 
}
6466
 
 
6467
 
my_decimal *Item_type_holder::val_decimal(my_decimal *)
6468
 
{
6469
 
  assert(0); // should never be called
6470
 
  return 0;
6471
 
}
6472
 
 
6473
 
String *Item_type_holder::val_str(String*)
6474
 
{
6475
 
  assert(0); // should never be called
6476
 
  return 0;
6477
 
}
6478
 
 
6479
 
void Item_result_field::cleanup()
6480
 
{
6481
 
  Item::cleanup();
6482
 
  result_field= 0;
6483
 
  return;
6484
 
}
6485
 
 
6486
 
/**
6487
 
  Dummy error processor used by default by Name_resolution_context.
6488
 
 
6489
 
  @note
6490
 
    do nothing
6491
 
*/
6492
 
 
6493
 
void dummy_error_processor(THD *thd __attribute__((unused)),
6494
 
                           void *data __attribute__((unused)))
6495
 
{}
6496
 
 
6497
 
/**
6498
 
  Wrapper of hide_view_error call for Name_resolution_context error
6499
 
  processor.
6500
 
 
6501
 
  @note
6502
 
    hide view underlying tables details in error messages
6503
 
*/
6504
 
 
6505
 
/*****************************************************************************
6506
 
** Instantiate templates
6507
 
*****************************************************************************/
 
1600
    new_field= 0;
 
1601
    break;
 
1602
  }
 
1603
  if (new_field)
 
1604
    new_field->init(table);
 
1605
 
 
1606
  if (copy_func && item->is_result_field())
 
1607
    *((*copy_func)++) = item;                   // Save for copy_funcs
 
1608
  if (modify_item)
 
1609
    item->set_result_field(new_field);
 
1610
  if (item->type() == Item::NULL_ITEM)
 
1611
    new_field->is_created_from_null_item= true;
 
1612
  return new_field;
 
1613
}
 
1614
 
 
1615
Field *create_tmp_field(Session *session,
 
1616
                        Table *table,
 
1617
                        Item *item,
 
1618
                        Item::Type type, 
 
1619
                        Item ***copy_func, 
 
1620
                        Field **from_field,
 
1621
                        Field **default_field, 
 
1622
                        bool group, 
 
1623
                        bool modify_item,
 
1624
                        bool, 
 
1625
                        bool make_copy_field,
 
1626
                        uint32_t convert_blob_length)
 
1627
{
 
1628
  Field *result;
 
1629
  Item::Type orig_type= type;
 
1630
  Item *orig_item= 0;
 
1631
 
 
1632
  if (type != Item::FIELD_ITEM &&
 
1633
      item->real_item()->type() == Item::FIELD_ITEM)
 
1634
  {
 
1635
    orig_item= item;
 
1636
    item= item->real_item();
 
1637
    type= Item::FIELD_ITEM;
 
1638
  }
 
1639
 
 
1640
  switch (type) {
 
1641
  case Item::SUM_FUNC_ITEM:
 
1642
  {
 
1643
    Item_sum *item_sum=(Item_sum*) item;
 
1644
    result= item_sum->create_tmp_field(group, table, convert_blob_length);
 
1645
    if (!result)
 
1646
      my_error(ER_OUT_OF_RESOURCES, MYF(ME_FATALERROR));
 
1647
    return result;
 
1648
  }
 
1649
  case Item::FIELD_ITEM:
 
1650
  case Item::DEFAULT_VALUE_ITEM:
 
1651
  {
 
1652
    Item_field *field= (Item_field*) item;
 
1653
    bool orig_modify= modify_item;
 
1654
    if (orig_type == Item::REF_ITEM)
 
1655
      modify_item= 0;
 
1656
    /*
 
1657
      If item have to be able to store NULLs but underlaid field can't do it,
 
1658
      create_tmp_field_from_field() can't be used for tmp field creation.
 
1659
    */
 
1660
    if (field->maybe_null && !field->field->maybe_null())
 
1661
    {
 
1662
      result= create_tmp_field_from_item(session, item, table, NULL,
 
1663
                                         modify_item, convert_blob_length);
 
1664
      *from_field= field->field;
 
1665
      if (result && modify_item)
 
1666
        field->result_field= result;
 
1667
    }
 
1668
    else
 
1669
      result= create_tmp_field_from_field(session, (*from_field= field->field),
 
1670
                                          orig_item ? orig_item->name :
 
1671
                                          item->name,
 
1672
                                          table,
 
1673
                                          modify_item ? field :
 
1674
                                          NULL,
 
1675
                                          convert_blob_length);
 
1676
    if (orig_type == Item::REF_ITEM && orig_modify)
 
1677
      ((Item_ref*)orig_item)->set_result_field(result);
 
1678
    if (field->field->eq_def(result))
 
1679
      *default_field= field->field;
 
1680
    return result;
 
1681
  }
 
1682
  /* Fall through */
 
1683
  case Item::FUNC_ITEM:
 
1684
    /* Fall through */
 
1685
  case Item::COND_ITEM:
 
1686
  case Item::FIELD_AVG_ITEM:
 
1687
  case Item::FIELD_STD_ITEM:
 
1688
  case Item::SUBSELECT_ITEM:
 
1689
    /* The following can only happen with 'CREATE TABLE ... SELECT' */
 
1690
  case Item::PROC_ITEM:
 
1691
  case Item::INT_ITEM:
 
1692
  case Item::REAL_ITEM:
 
1693
  case Item::DECIMAL_ITEM:
 
1694
  case Item::STRING_ITEM:
 
1695
  case Item::REF_ITEM:
 
1696
  case Item::NULL_ITEM:
 
1697
  case Item::VARBIN_ITEM:
 
1698
    if (make_copy_field)
 
1699
    {
 
1700
      assert(((Item_result_field*)item)->result_field);
 
1701
      *from_field= ((Item_result_field*)item)->result_field;
 
1702
    }
 
1703
    return create_tmp_field_from_item(session, item, table,
 
1704
                                      (make_copy_field ? 0 : copy_func),
 
1705
                                       modify_item, convert_blob_length);
 
1706
  case Item::TYPE_HOLDER:
 
1707
    result= ((Item_type_holder *)item)->make_field_by_type(table);
 
1708
    result->set_derivation(item->collation.derivation);
 
1709
    return result;
 
1710
  default:                                      // Dosen't have to be stored
 
1711
    return NULL;
 
1712
  }
 
1713
}
6508
1714
 
6509
1715
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
6510
1716
template class List<Item>;