← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item.cc

  • Committer: Brian Aker
  • Date: 2010-01-22 00:53:13 UTC
  • Revision ID: brian@gaz-20100122005313-jmizcbcdi1lt4tcx
Revert db patch.

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 "config.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
#include "drizzled/time_functions.h"
 
34
 
 
35
#include "drizzled/field/str.h"
 
36
#include "drizzled/field/num.h"
 
37
#include "drizzled/field/blob.h"
 
38
#include "drizzled/field/enum.h"
 
39
#include "drizzled/field/null.h"
 
40
#include "drizzled/field/date.h"
 
41
#include "drizzled/field/decimal.h"
 
42
#include "drizzled/field/real.h"
 
43
#include "drizzled/field/double.h"
 
44
#include "drizzled/field/long.h"
 
45
#include "drizzled/field/int64_t.h"
 
46
#include "drizzled/field/num.h"
 
47
#include "drizzled/field/timestamp.h"
 
48
#include "drizzled/field/datetime.h"
 
49
#include "drizzled/field/varstring.h"
 
50
#include "drizzled/internal/m_string.h"
 
51
 
 
52
#include <math.h>
 
53
#include <algorithm>
 
54
#include <float.h>
 
55
 
 
56
using namespace std;
 
57
using namespace drizzled;
20
58
 
21
59
const String my_null_string("NULL", 4, default_charset_info);
22
60
 
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
 
 
 
61
bool Item::is_expensive_processor(unsigned char *)
 
62
{
 
63
  return false;
 
64
}
 
65
 
 
66
void Item::fix_after_pullout(Select_Lex *, Item **)
 
67
{}
 
68
 
 
69
Field *Item::tmp_table_field(Table *)
 
70
{
 
71
  return NULL;
 
72
}
 
73
 
 
74
const char *Item::full_name(void) const
 
75
{
 
76
  return name ? name : "???";
 
77
}
 
78
 
 
79
int64_t Item::val_int_endpoint(bool, bool *)
 
80
{
 
81
  assert(0);
 
82
  return 0;
 
83
}
 
84
 
 
85
/** @todo Make this functions class dependent */
172
86
bool Item::val_bool()
173
87
{
174
 
  switch(result_type()) {
175
 
  case INT_RESULT:
176
 
    return val_int() != 0;
177
 
  case DECIMAL_RESULT:
 
88
  switch(result_type()) 
178
89
  {
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)
 
90
    case INT_RESULT:
 
91
      return val_int() != 0;
 
92
    case DECIMAL_RESULT:
 
93
    {
 
94
      my_decimal decimal_value;
 
95
      my_decimal *val= val_decimal(&decimal_value);
 
96
      if (val)
 
97
        return !my_decimal_is_zero(val);
 
98
      return false;
 
99
    }
 
100
    case REAL_RESULT:
 
101
    case STRING_RESULT:
 
102
      return val_real() != 0.0;
 
103
    case ROW_RESULT:
 
104
    default:
 
105
      assert(0);
 
106
      return false;
192
107
  }
193
108
}
194
109
 
195
 
 
196
110
String *Item::val_string_from_real(String *str)
197
111
{
198
112
  double nr= val_real();
199
113
  if (null_value)
200
 
    return 0;                                   /* purecov: inspected */
201
 
  str->set_real(nr,decimals, &my_charset_bin);
 
114
    return NULL;
 
115
 
 
116
  str->set_real(nr, decimals, &my_charset_bin);
202
117
  return str;
203
118
}
204
119
 
205
 
 
206
120
String *Item::val_string_from_int(String *str)
207
121
{
208
122
  int64_t nr= val_int();
209
123
  if (null_value)
210
 
    return 0;
 
124
    return NULL;
 
125
 
211
126
  str->set_int(nr, unsigned_flag, &my_charset_bin);
212
127
  return str;
213
128
}
214
129
 
215
 
 
216
130
String *Item::val_string_from_decimal(String *str)
217
131
{
218
132
  my_decimal dec_buf, *dec= val_decimal(&dec_buf);
219
133
  if (null_value)
220
 
    return 0;
 
134
    return NULL;
 
135
 
221
136
  my_decimal_round(E_DEC_FATAL_ERROR, dec, decimals, false, &dec_buf);
222
137
  my_decimal2string(E_DEC_FATAL_ERROR, &dec_buf, 0, 0, 0, str);
223
138
  return str;
224
139
}
225
140
 
226
 
 
227
141
my_decimal *Item::val_decimal_from_real(my_decimal *decimal_value)
228
142
{
229
143
  double nr= val_real();
230
144
  if (null_value)
231
 
    return 0;
 
145
    return NULL;
 
146
 
232
147
  double2my_decimal(E_DEC_FATAL_ERROR, nr, decimal_value);
233
148
  return (decimal_value);
234
149
}
235
150
 
236
 
 
237
151
my_decimal *Item::val_decimal_from_int(my_decimal *decimal_value)
238
152
{
239
153
  int64_t nr= val_int();
240
154
  if (null_value)
241
 
    return 0;
 
155
    return NULL;
 
156
 
242
157
  int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, decimal_value);
243
158
  return decimal_value;
244
159
}
245
160
 
246
 
 
247
161
my_decimal *Item::val_decimal_from_string(my_decimal *decimal_value)
248
162
{
249
163
  String *res;
250
164
  char *end_ptr;
251
165
  if (!(res= val_str(&str_value)))
252
 
    return 0;                                   // NULL or EOM
 
166
    return NULL;
253
167
 
254
168
  end_ptr= (char*) res->ptr()+ res->length();
255
169
  if (str2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_BAD_NUM,
256
 
                     res->ptr(), res->length(), res->charset(),
 
170
                     res->ptr(), 
 
171
                     res->length(), 
 
172
                     res->charset(),
257
173
                     decimal_value) & E_DEC_BAD_NUM)
258
174
  {
259
 
    push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
175
    push_warning_printf(current_session, 
 
176
                        DRIZZLE_ERROR::WARN_LEVEL_WARN,
260
177
                        ER_TRUNCATED_WRONG_VALUE,
261
178
                        ER(ER_TRUNCATED_WRONG_VALUE), "DECIMAL",
262
179
                        str_value.c_ptr());
264
181
  return decimal_value;
265
182
}
266
183
 
267
 
 
268
184
my_decimal *Item::val_decimal_from_date(my_decimal *decimal_value)
269
185
{
270
 
  assert(fixed == 1);
 
186
  assert(fixed);
271
187
  DRIZZLE_TIME ltime;
272
188
  if (get_date(&ltime, TIME_FUZZY_DATE))
273
189
  {
274
190
    my_decimal_set_zero(decimal_value);
275
191
    null_value= 1;                               // set NULL, stop processing
276
 
    return 0;
 
192
    return NULL;
277
193
  }
278
194
  return date2my_decimal(&ltime, decimal_value);
279
195
}
280
196
 
281
 
 
282
197
my_decimal *Item::val_decimal_from_time(my_decimal *decimal_value)
283
198
{
284
 
  assert(fixed == 1);
 
199
  assert(fixed);
285
200
  DRIZZLE_TIME ltime;
286
201
  if (get_time(&ltime))
287
202
  {
288
203
    my_decimal_set_zero(decimal_value);
289
 
    return 0;
 
204
    return NULL;
290
205
  }
291
206
  return date2my_decimal(&ltime, decimal_value);
292
207
}
293
208
 
294
 
 
295
209
double Item::val_real_from_decimal()
296
210
{
297
211
  /* Note that fix_fields may not be called for Item_avg_field items */
303
217
  return result;
304
218
}
305
219
 
306
 
 
307
220
int64_t Item::val_int_from_decimal()
308
221
{
309
222
  /* Note that fix_fields may not be called for Item_avg_field items */
324
237
  return field->store_time(&ltime, DRIZZLE_TIMESTAMP_TIME);
325
238
}
326
239
 
327
 
 
328
240
int Item::save_date_in_field(Field *field)
329
241
{
330
242
  DRIZZLE_TIME ltime;
334
246
  return field->store_time(&ltime, DRIZZLE_TIMESTAMP_DATETIME);
335
247
}
336
248
 
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
 
 
 
249
/**
 
250
 * Check if the Item is null and stores the NULL or the
 
251
 * result value in the field accordingly.
 
252
 */
359
253
int Item::save_str_value_in_field(Field *field, String *result)
360
254
{
361
255
  if (null_value)
362
256
    return set_field_to_null(field);
363
257
  field->set_notnull();
364
 
  return field->store(result->ptr(), result->length(),
365
 
                      collation.collation);
 
258
  return field->store(result->ptr(), result->length(), collation.collation);
366
259
}
367
260
 
368
 
 
369
261
Item::Item():
370
 
  is_expensive_cache(-1), rsize(0), name(0), orig_name(0), name_length(0),
371
 
  fixed(0), is_autogenerated_name(true),
 
262
  is_expensive_cache(-1),
 
263
  name(0), 
 
264
  name_length(0),
 
265
  orig_name(0), 
 
266
  max_length(0), 
 
267
  marker(0),
 
268
  decimals(0),
 
269
  fixed(false),
 
270
  maybe_null(false),
 
271
  null_value(false),
 
272
  unsigned_flag(false), 
 
273
  with_sum_func(false),
 
274
  is_autogenerated_name(true),
 
275
  with_subselect(false),
372
276
  collation(&my_charset_bin, DERIVATION_COERCIBLE)
373
277
{
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
278
  cmp_context= (Item_result)-1;
383
279
 
384
280
  /* 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;
 
281
  Session *session= current_session;
 
282
  next= session->free_list;
 
283
  session->free_list= this;
 
284
 
388
285
  /*
389
286
    Item constructor can be called during execution other then SQL_COM
390
 
    command => we should check thd->lex->current_select on zero (thd->lex
 
287
    command => we should check session->lex->current_select on zero (session->lex
391
288
    can be uninitialised)
392
289
  */
393
 
  if (thd->lex->current_select)
 
290
  if (session->lex->current_select)
394
291
  {
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++;
 
292
    enum_parsing_place place= session->lex->current_select->parsing_place;
 
293
    if (place == SELECT_LIST || place == IN_HAVING)
 
294
      session->lex->current_select->select_n_having_items++;
400
295
  }
401
296
}
402
297
 
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):
 
298
Item::Item(Session *session, Item *item):
411
299
  is_expensive_cache(-1),
412
 
  rsize(0),
413
300
  str_value(item->str_value),
414
301
  name(item->name),
 
302
  name_length(item->name_length),
415
303
  orig_name(item->orig_name),
416
304
  max_length(item->max_length),
417
305
  marker(item->marker),
418
306
  decimals(item->decimals),
 
307
  fixed(item->fixed),
419
308
  maybe_null(item->maybe_null),
420
309
  null_value(item->null_value),
421
310
  unsigned_flag(item->unsigned_flag),
422
311
  with_sum_func(item->with_sum_func),
423
 
  fixed(item->fixed),
 
312
  is_autogenerated_name(item->is_autogenerated_name),
 
313
  with_subselect(item->with_subselect),
424
314
  collation(item->collation),
425
315
  cmp_context(item->cmp_context)
426
316
{
427
 
  next= thd->free_list;                         // Put in free list
428
 
  thd->free_list= this;
429
 
}
430
 
 
431
 
 
432
 
uint Item::decimal_precision() const
 
317
  /* Put this item in the session's free list */
 
318
  next= session->free_list;
 
319
  session->free_list= this;
 
320
}
 
321
 
 
322
uint32_t Item::float_length(uint32_t decimals_par) const
 
323
{
 
324
  return decimals != NOT_FIXED_DEC ? (DBL_DIG+2+decimals_par) : DBL_DIG+8;
 
325
}
 
326
 
 
327
uint32_t Item::decimal_precision() const
433
328
{
434
329
  Item_result restype= result_type();
435
330
 
436
331
  if ((restype == DECIMAL_RESULT) || (restype == INT_RESULT))
437
332
    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
 
 
 
333
               (uint32_t) DECIMAL_MAX_PRECISION);
 
334
  return min(max_length, (uint32_t) DECIMAL_MAX_PRECISION);
 
335
}
 
336
 
 
337
int Item::decimal_int_part() const
 
338
{
 
339
  return my_decimal_int_part(decimal_precision(), decimals);
 
340
}
 
341
 
 
342
void Item::print(String *str, enum_query_type)
 
343
{
 
344
  str->append(full_name());
 
345
}
442
346
 
443
347
void Item::print_item_w_name(String *str, enum_query_type query_type)
444
348
{
446
350
 
447
351
  if (name)
448
352
  {
449
 
    THD *thd= current_thd;
450
353
    str->append(STRING_WITH_LEN(" AS "));
451
 
    append_identifier(thd, str, name, (uint) strlen(name));
 
354
    str->append_identifier(name, (uint32_t) strlen(name));
452
355
  }
453
356
}
454
357
 
 
358
void Item::split_sum_func(Session *, Item **, List<Item> &)
 
359
{}
455
360
 
456
361
void Item::cleanup()
457
362
{
458
 
  fixed=0;
 
363
  fixed= false;
459
364
  marker= 0;
460
365
  if (orig_name)
461
366
    name= orig_name;
462
367
  return;
463
368
}
464
369
 
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
370
void Item::rename(char *new_name)
487
371
{
488
372
  /*
489
373
    we can compare pointers to names here, because if name was not changed,
490
374
    pointer will be same
491
375
  */
492
 
  if (!orig_name && new_name != name)
 
376
  if (! orig_name && new_name != name)
493
377
    orig_name= name;
494
378
  name= new_name;
495
379
}
496
380
 
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)
 
381
Item* Item::transform(Item_transformer transformer, unsigned char *arg)
528
382
{
529
383
  return (this->*transformer)(arg);
530
384
}
531
385
 
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)
 
386
bool Item::check_cols(uint32_t c)
674
387
{
675
388
  if (c != 1)
676
389
  {
677
390
    my_error(ER_OPERAND_COLUMNS, MYF(0), c);
678
 
    return 1;
 
391
    return true;
679
392
  }
680
 
  return 0;
 
393
  return false;
681
394
}
682
395
 
683
 
 
684
 
void Item::set_name(const char *str, uint length, const CHARSET_INFO * const cs)
 
396
void Item::set_name(const char *str, uint32_t length, const CHARSET_INFO * const cs)
685
397
{
686
398
  if (!length)
687
399
  {
692
404
  }
693
405
  if (cs->ctype)
694
406
  {
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
 
407
    uint32_t orig_len= length;
 
408
    while (length && ! my_isgraph(cs, *str))
 
409
    {
 
410
      /* Fix problem with yacc */
702
411
      length--;
703
412
      str++;
704
413
    }
705
 
    if (orig_len != length && !is_autogenerated_name)
 
414
    if (orig_len != length && ! is_autogenerated_name)
706
415
    {
707
416
      if (length == 0)
708
 
        push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
709
 
                            ER_NAME_BECOMES_EMPTY, ER(ER_NAME_BECOMES_EMPTY),
 
417
        push_warning_printf(current_session, 
 
418
                            DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
419
                            ER_NAME_BECOMES_EMPTY, 
 
420
                            ER(ER_NAME_BECOMES_EMPTY),
710
421
                            str + length - orig_len);
711
422
      else
712
 
        push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
713
 
                            ER_REMOVED_SPACES, ER(ER_REMOVED_SPACES),
 
423
        push_warning_printf(current_session, 
 
424
                            DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
425
                            ER_REMOVED_SPACES, 
 
426
                            ER(ER_REMOVED_SPACES),
714
427
                            str + length - orig_len);
715
428
    }
716
429
  }
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)));
 
430
  name= memory::sql_strmake(str, length);
726
431
}
727
432
 
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
 
433
bool Item::eq(const Item *item, bool) const
737
434
{
738
435
  /*
739
436
    Note, that this is never true if item is a Item_param:
740
437
    for all basic constants we have special checks, and Item_param's
741
438
    type() can be only among basic constant types.
742
439
  */
743
 
  return type() == item->type() && name && item->name &&
744
 
    !my_strcasecmp(system_charset_info,name,item->name);
 
440
  return type() == item->type() && 
 
441
         name && 
 
442
         item->name &&
 
443
         ! my_strcasecmp(system_charset_info, name, item->name);
745
444
}
746
445
 
747
 
 
748
446
Item *Item::safe_charset_converter(const CHARSET_INFO * const tocs)
749
447
{
750
448
  Item_func_conv_charset *conv= new Item_func_conv_charset(this, tocs, 1);
751
449
  return conv->safe ? conv : NULL;
752
450
}
753
451
 
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)
 
452
bool Item::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
889
453
{
890
454
  if (result_type() == STRING_RESULT)
891
455
  {
900
464
  {
901
465
    int64_t value= val_int();
902
466
    int was_cut;
903
 
    if (number_to_datetime(value, ltime, fuzzydate, &was_cut) == -1LL)
 
467
    if (number_to_datetime(value, ltime, fuzzydate, &was_cut) == -1L)
904
468
    {
905
469
      char buff[22], *end;
906
470
      end= int64_t10_to_str(value, buff, -10);
907
 
      make_truncated_value_warning(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
471
      make_truncated_value_warning(current_session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
908
472
                                   buff, (int) (end-buff), DRIZZLE_TIMESTAMP_NONE,
909
 
                                   NullS);
 
473
                                   NULL);
910
474
      goto err;
911
475
    }
912
476
  }
913
 
  return 0;
 
477
  return false;
914
478
 
915
479
err:
916
480
  memset(ltime, 0, sizeof(*ltime));
917
 
  return 1;
 
481
  return true;
918
482
}
919
483
 
920
 
/**
921
 
  Get time of first argument.\
922
 
 
923
 
  As a extra convenience the time structure is reset on error!
924
 
*/
925
 
 
926
484
bool Item::get_time(DRIZZLE_TIME *ltime)
927
485
{
928
486
  char buff[40];
931
489
      str_to_time_with_warn(res->ptr(), res->length(), ltime))
932
490
  {
933
491
    memset(ltime, 0, sizeof(*ltime));
934
 
    return 1;
 
492
    return true;
935
493
  }
936
 
  return 0;
 
494
  return false;
 
495
}
 
496
 
 
497
bool Item::get_date_result(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
 
498
{
 
499
  return get_date(ltime,fuzzydate);
 
500
}
 
501
 
 
502
bool Item::is_null()
 
503
{
 
504
  return false;
 
505
}
 
506
 
 
507
void Item::update_null_value ()
 
508
{
 
509
  (void) val_int();
 
510
}
 
511
 
 
512
void Item::top_level_item(void)
 
513
{}
 
514
 
 
515
void Item::set_result_field(Field *)
 
516
{}
 
517
 
 
518
bool Item::is_result_field(void)
 
519
{
 
520
  return false;
 
521
}
 
522
 
 
523
bool Item::is_bool_func(void)
 
524
{
 
525
  return false;
 
526
}
 
527
 
 
528
void Item::save_in_result_field(bool)
 
529
{}
 
530
 
 
531
void Item::no_rows_in_result(void)
 
532
{}
 
533
 
 
534
Item *Item::copy_or_same(Session *)
 
535
{
 
536
  return this;
 
537
}
 
538
 
 
539
Item *Item::copy_andor_structure(Session *)
 
540
{
 
541
  return this;
 
542
}
 
543
 
 
544
Item *Item::real_item(void)
 
545
{
 
546
  return this;
 
547
}
 
548
 
 
549
const Item *Item::real_item(void) const
 
550
{
 
551
  return this;
 
552
}
 
553
 
 
554
Item *Item::get_tmp_table_item(Session *session)
 
555
{
 
556
  return copy_or_same(session);
937
557
}
938
558
 
939
559
const CHARSET_INFO *Item::default_charset()
940
560
{
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
 
*/
 
561
  return current_session->variables.getCollation();
 
562
}
 
563
 
 
564
const CHARSET_INFO *Item::compare_collation()
 
565
{
 
566
  return NULL;
 
567
}
 
568
 
 
569
bool Item::walk(Item_processor processor, bool, unsigned char *arg)
 
570
{
 
571
  return (this->*processor)(arg);
 
572
}
 
573
 
 
574
Item* Item::compile(Item_analyzer analyzer, 
 
575
                    unsigned char **arg_p,
 
576
                    Item_transformer transformer, 
 
577
                    unsigned char *arg_t)
 
578
{
 
579
  if ((this->*analyzer) (arg_p))
 
580
    return ((this->*transformer) (arg_t));
 
581
  return NULL;
 
582
}
 
583
 
 
584
void Item::traverse_cond(Cond_traverser traverser, void *arg, traverse_order)
 
585
{
 
586
  (*traverser)(this, arg);
 
587
}
 
588
 
 
589
bool Item::remove_dependence_processor(unsigned char *)
 
590
{
 
591
  return false;
 
592
}
 
593
 
 
594
bool Item::remove_fixed(unsigned char *)
 
595
{
 
596
  fixed= false;
 
597
  return false;
 
598
}
 
599
 
 
600
bool Item::collect_item_field_processor(unsigned char *)
 
601
{
 
602
  return false;
 
603
}
 
604
 
 
605
bool Item::find_item_in_field_list_processor(unsigned char *)
 
606
{
 
607
  return false;
 
608
}
 
609
 
 
610
bool Item::change_context_processor(unsigned char *)
 
611
{
 
612
  return false;
 
613
}
 
614
 
 
615
bool Item::reset_query_id_processor(unsigned char *)
 
616
{
 
617
  return false;
 
618
}
 
619
 
 
620
bool Item::register_field_in_read_map(unsigned char *)
 
621
{
 
622
  return false;
 
623
}
 
624
 
 
625
bool Item::subst_argument_checker(unsigned char **arg)
 
626
{
 
627
  if (*arg)
 
628
    *arg= NULL;
 
629
  return true;
 
630
}
 
631
 
 
632
Item *Item::equal_fields_propagator(unsigned char *)
 
633
{
 
634
  return this;
 
635
}
 
636
 
 
637
bool Item::set_no_const_sub(unsigned char *)
 
638
{
 
639
  return false;
 
640
}
 
641
 
 
642
Item *Item::replace_equal_field(unsigned char *)
 
643
{
 
644
  return this;
 
645
}
 
646
 
 
647
uint32_t Item::cols()
 
648
{
 
649
  return 1;
 
650
}
 
651
 
 
652
Item* Item::element_index(uint32_t)
 
653
{
 
654
  return this;
 
655
}
 
656
 
 
657
Item** Item::addr(uint32_t)
 
658
{
 
659
  return NULL;
 
660
}
 
661
 
 
662
bool Item::null_inside()
 
663
{
 
664
  return false;
 
665
}
 
666
 
 
667
void Item::bring_value()
 
668
{}
 
669
 
 
670
Item *Item::neg_transformer(Session *)
 
671
{
 
672
  return NULL;
 
673
}
 
674
 
 
675
Item *Item::update_value_transformer(unsigned char *)
 
676
{
 
677
  return this;
 
678
}
 
679
 
 
680
void Item::delete_self()
 
681
{
 
682
  cleanup();
 
683
  delete this;
 
684
}
 
685
 
 
686
bool Item::result_as_int64_t()
 
687
{
 
688
  return false;
 
689
}
 
690
 
 
691
bool Item::is_expensive()
 
692
{
 
693
  if (is_expensive_cache < 0)
 
694
    is_expensive_cache= walk(&Item::is_expensive_processor, 0,
 
695
                             (unsigned char*)0);
 
696
  return test(is_expensive_cache);
 
697
}
952
698
 
953
699
int Item::save_in_field_no_warnings(Field *field, bool no_conversions)
954
700
{
955
701
  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;
 
702
  Table *table= field->table;
 
703
  Session *session= table->in_use;
 
704
  enum_check_fields tmp= session->count_cuted_fields;
 
705
  ulong sql_mode= session->variables.sql_mode;
 
706
  session->variables.sql_mode&= ~(MODE_NO_ZERO_DATE);
 
707
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
963
708
  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;
 
709
  session->count_cuted_fields= tmp;
 
710
  session->variables.sql_mode= sql_mode;
967
711
  return res;
968
712
}
969
713
 
970
 
 
971
714
/*
972
 
 need a special class to adjust printing : references to aggregate functions 
 
715
 need a special class to adjust printing : references to aggregate functions
973
716
 must not be printed as refs because the aggregate functions that are added to
974
717
 the front of select list are not printed as well.
975
718
*/
989
732
  }
990
733
};
991
734
 
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)
 
735
void Item::split_sum_func(Session *session, Item **ref_pointer_array,
 
736
                          List<Item> &fields, Item **ref,
 
737
                          bool skip_registered)
1015
738
{
1016
 
  /* An item of type Item_sum  is registered <=> ref_by != 0 */ 
1017
 
  if (type() == SUM_FUNC_ITEM && skip_registered && 
 
739
  /* An item of type Item_sum  is registered <=> ref_by != 0 */
 
740
  if (type() == SUM_FUNC_ITEM && 
 
741
      skip_registered &&
1018
742
      ((Item_sum *) this)->ref_by)
1019
 
    return;                                                 
 
743
    return;
 
744
 
1020
745
  if ((type() != SUM_FUNC_ITEM && with_sum_func) ||
1021
746
      (type() == FUNC_ITEM &&
1022
747
       (((Item_func *) this)->functype() == Item_func::ISNOTNULLTEST_FUNC ||
1023
748
        ((Item_func *) this)->functype() == Item_func::TRIG_COND_FUNC)))
1024
749
  {
1025
750
    /* Will split complicated items and ignore simple ones */
1026
 
    split_sum_func(thd, ref_pointer_array, fields);
 
751
    split_sum_func(session, ref_pointer_array, fields);
1027
752
  }
1028
753
  else if ((type() == SUM_FUNC_ITEM || (used_tables() & ~PARAM_TABLE_BIT)) &&
1029
754
           type() != SUBSELECT_ITEM &&
1030
 
           (type() != REF_ITEM ||
1031
 
           ((Item_ref*)this)->ref_type() == Item_ref::VIEW_REF))
 
755
           type() != REF_ITEM)
1032
756
  {
1033
757
    /*
1034
758
      Replace item with a reference so that we can easily calculate
1041
765
      Item_ref to allow fields from view being stored in tmp table.
1042
766
    */
1043
767
    Item_aggregate_ref *item_ref;
1044
 
    uint el= fields.elements;
 
768
    uint32_t el= fields.elements;
1045
769
    Item *real_itm= real_item();
1046
770
 
1047
771
    ref_pointer_array[el]= real_itm;
1048
 
    if (!(item_ref= new Item_aggregate_ref(&thd->lex->current_select->context,
 
772
    if (!(item_ref= new Item_aggregate_ref(&session->lex->current_select->context,
1049
773
                                           ref_pointer_array + el, 0, name)))
1050
 
      return;                                   // fatal_error is set
 
774
      return; /* fatal_error is set */
1051
775
    if (type() == SUM_FUNC_ITEM)
1052
 
      item_ref->depended_from= ((Item_sum *) this)->depended_from(); 
 
776
      item_ref->depended_from= ((Item_sum *) this)->depended_from();
1053
777
    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
 
 
 
778
    session->change_item_tree(ref, item_ref);
 
779
  }
 
780
}
2827
781
 
2828
782
/*
2829
783
  Functions to convert item to field (for send_fields)
2830
784
*/
2831
 
 
2832
 
/* ARGSUSED */
2833
 
bool Item::fix_fields(THD *thd __attribute__((unused)),
2834
 
                      Item **ref __attribute__((unused)))
 
785
bool Item::fix_fields(Session *, Item **)
2835
786
{
2836
 
 
2837
 
  // We do not check fields which are fixed during construction
2838
 
  assert(fixed == 0 || basic_const_item());
2839
 
  fixed= 1;
 
787
  /* We do not check fields which are fixed during construction */
 
788
  assert(! fixed || basic_const_item());
 
789
  fixed= true;
2840
790
  return false;
2841
791
}
2842
792
 
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,
 
793
void mark_as_dependent(Session *session, Select_Lex *last, Select_Lex *current,
2907
794
                              Item_ident *resolved_item,
2908
795
                              Item_ident *mark_item)
2909
796
{
2911
798
                        resolved_item->db_name : "");
2912
799
  const char *table_name= (resolved_item->table_name ?
2913
800
                           resolved_item->table_name : "");
2914
 
  /* store pointer on SELECT_LEX from which item is dependent */
 
801
  /* store pointer on Select_Lex from which item is dependent */
2915
802
  if (mark_item)
2916
803
    mark_item->depended_from= last;
2917
804
  current->mark_as_dependent(last);
2918
 
  if (thd->lex->describe & DESCRIBE_EXTENDED)
 
805
  if (session->lex->describe & DESCRIBE_EXTENDED)
2919
806
  {
2920
807
    char warn_buff[DRIZZLE_ERRMSG_SIZE];
2921
808
    sprintf(warn_buff, ER(ER_WARN_FIELD_RESOLVED),
2923
810
            table_name, (table_name [0] ? "." : ""),
2924
811
            resolved_item->field_name,
2925
812
            current->select_number, last->select_number);
2926
 
    push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
813
    push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
2927
814
                 ER_WARN_FIELD_RESOLVED, warn_buff);
2928
815
  }
2929
816
}
2930
817
 
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,
 
818
void mark_select_range_as_dependent(Session *session,
 
819
                                    Select_Lex *last_select,
 
820
                                    Select_Lex *current_sel,
2955
821
                                    Field *found_field, Item *found_item,
2956
822
                                    Item_ident *resolved_item)
2957
823
{
2961
827
    done once when we resolved this field and cached result of
2962
828
    resolving)
2963
829
  */
2964
 
  SELECT_LEX *previous_select= current_sel;
 
830
  Select_Lex *previous_select= current_sel;
2965
831
  for (; previous_select->outer_select() != last_select;
2966
832
       previous_select= previous_select->outer_select())
2967
833
  {
2968
 
    Item_subselect *prev_subselect_item=
2969
 
      previous_select->master_unit()->item;
 
834
    Item_subselect *prev_subselect_item= previous_select->master_unit()->item;
2970
835
    prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
2971
836
    prev_subselect_item->const_item_cache= 0;
2972
837
  }
2973
838
  {
2974
 
    Item_subselect *prev_subselect_item=
2975
 
      previous_select->master_unit()->item;
 
839
    Item_subselect *prev_subselect_item= previous_select->master_unit()->item;
2976
840
    Item_ident *dependent= resolved_item;
2977
841
    if (found_field == view_ref_found)
2978
842
    {
2979
843
      Item::Type type= found_item->type();
2980
 
      prev_subselect_item->used_tables_cache|=
2981
 
        found_item->used_tables();
 
844
      prev_subselect_item->used_tables_cache|= found_item->used_tables();
2982
845
      dependent= ((type == Item::REF_ITEM || type == Item::FIELD_ITEM) ?
2983
846
                  (Item_ident*) found_item :
2984
847
                  0);
2985
848
    }
2986
849
    else
2987
 
      prev_subselect_item->used_tables_cache|=
2988
 
        found_field->table->map;
 
850
      prev_subselect_item->used_tables_cache|= found_field->table->map;
2989
851
    prev_subselect_item->const_item_cache= 0;
2990
 
    mark_as_dependent(thd, last_select, current_sel, resolved_item,
 
852
    mark_as_dependent(session, last_select, current_sel, resolved_item,
2991
853
                      dependent);
2992
854
  }
2993
855
}
2994
856
 
2995
 
 
2996
857
/**
2997
858
  Search a GROUP BY clause for a field with a certain name.
2998
859
 
3007
868
    - the found item on success
3008
869
    - NULL if find_item is not in group_list
3009
870
*/
3010
 
 
3011
 
static Item** find_field_in_group_list(Item *find_item, ORDER *group_list)
 
871
static Item** find_field_in_group_list(Item *find_item, order_st *group_list)
3012
872
{
3013
873
  const char *db_name;
3014
874
  const char *table_name;
3015
875
  const char *field_name;
3016
 
  ORDER      *found_group= NULL;
3017
 
  int         found_match_degree= 0;
 
876
  order_st *found_group= NULL;
 
877
  int found_match_degree= 0;
3018
878
  Item_ident *cur_field;
3019
 
  int         cur_match_degree= 0;
3020
 
  char        name_buff[NAME_LEN+1];
 
879
  int cur_match_degree= 0;
 
880
  char name_buff[NAME_LEN+1];
3021
881
 
3022
882
  if (find_item->type() == Item::FIELD_ITEM ||
3023
883
      find_item->type() == Item::REF_ITEM)
3024
884
  {
3025
 
    db_name=    ((Item_ident*) find_item)->db_name;
 
885
    db_name= ((Item_ident*) find_item)->db_name;
3026
886
    table_name= ((Item_ident*) find_item)->table_name;
3027
887
    field_name= ((Item_ident*) find_item)->field_name;
3028
888
  }
3029
889
  else
3030
890
    return NULL;
3031
891
 
3032
 
  if (db_name && lower_case_table_names)
 
892
  if (db_name)
3033
893
  {
3034
894
    /* Convert database to lower case for comparison */
3035
 
    strmake(name_buff, db_name, sizeof(name_buff)-1);
 
895
    strncpy(name_buff, db_name, sizeof(name_buff)-1);
3036
896
    my_casedn_str(files_charset_info, name_buff);
3037
897
    db_name= name_buff;
3038
898
  }
3039
899
 
3040
900
  assert(field_name != 0);
3041
901
 
3042
 
  for (ORDER *cur_group= group_list ; cur_group ; cur_group= cur_group->next)
 
902
  for (order_st *cur_group= group_list ; cur_group ; cur_group= cur_group->next)
3043
903
  {
3044
904
    if ((*(cur_group->item))->real_item()->type() == Item::FIELD_ITEM)
3045
905
    {
3046
906
      cur_field= (Item_ident*) *cur_group->item;
3047
907
      cur_match_degree= 0;
3048
 
      
 
908
 
3049
909
      assert(cur_field->field_name != 0);
3050
910
 
3051
 
      if (!my_strcasecmp(system_charset_info,
3052
 
                         cur_field->field_name, field_name))
 
911
      if (! my_strcasecmp(system_charset_info, cur_field->field_name, field_name))
3053
912
        ++cur_match_degree;
3054
913
      else
3055
914
        continue;
3077
936
        found_match_degree= cur_match_degree;
3078
937
        found_group= cur_group;
3079
938
      }
3080
 
      else if (found_group && (cur_match_degree == found_match_degree) &&
 
939
      else if (found_group &&
 
940
               (cur_match_degree == found_match_degree) &&
3081
941
               ! (*(found_group->item))->eq(cur_field, 0))
3082
942
      {
3083
943
        /*
3085
945
          best match, they must reference the same column, otherwise the field
3086
946
          is ambiguous.
3087
947
        */
3088
 
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
3089
 
                 find_item->full_name(), current_thd->where);
 
948
        my_error(ER_NON_UNIQ_ERROR, MYF(0), find_item->full_name(), current_session->where);
3090
949
        return NULL;
3091
950
      }
3092
951
    }
3098
957
    return NULL;
3099
958
}
3100
959
 
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)
 
960
Item** resolve_ref_in_select_and_group(Session *session, Item_ident *ref, Select_Lex *select)
3140
961
{
3141
962
  Item **group_by_ref= NULL;
3142
963
  Item **select_ref= NULL;
3143
 
  ORDER *group_list= (ORDER*) select->group_list.first;
 
964
  order_st *group_list= (order_st*) select->group_list.first;
3144
965
  bool ambiguous_fields= false;
3145
 
  uint counter;
 
966
  uint32_t counter;
3146
967
  enum_resolution_type resolution;
3147
968
 
3148
969
  /*
3160
981
  if (select->having_fix_field && !ref->with_sum_func && group_list)
3161
982
  {
3162
983
    group_by_ref= find_field_in_group_list(ref, group_list);
3163
 
    
 
984
 
3164
985
    /* Check if the fields found in SELECT and GROUP BY are the same field. */
3165
986
    if (group_by_ref && (select_ref != not_found_item) &&
3166
987
        !((*group_by_ref)->eq(*select_ref, 0)))
3167
988
    {
3168
989
      ambiguous_fields= true;
3169
 
      push_warning_printf(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_NON_UNIQ_ERROR,
 
990
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_NON_UNIQ_ERROR,
3170
991
                          ER(ER_NON_UNIQ_ERROR), ref->full_name(),
3171
 
                          current_thd->where);
 
992
                          current_session->where);
3172
993
 
3173
994
    }
3174
995
  }
3196
1017
  return (Item**) not_found_item;
3197
1018
}
3198
1019
 
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,
 
1020
void Item::init_make_field(SendField *tmp_field,
3899
1021
                           enum enum_field_types field_type_arg)
3900
1022
{
3901
1023
  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;
 
1024
  tmp_field->db_name=   empty_name;
 
1025
  tmp_field->org_table_name= empty_name;
 
1026
  tmp_field->org_col_name= empty_name;
 
1027
  tmp_field->table_name= empty_name;
 
1028
  tmp_field->col_name= name;
 
1029
  tmp_field->charsetnr= collation.collation->number;
 
1030
  tmp_field->flags= (maybe_null ? 0 : NOT_NULL_FLAG) |
 
1031
                    (my_binary_compare(collation.collation) ?
 
1032
                      BINARY_FLAG : 0);
 
1033
  tmp_field->type= field_type_arg;
 
1034
  tmp_field->length= max_length;
 
1035
  tmp_field->decimals= decimals;
3916
1036
}
3917
1037
 
3918
 
void Item::make_field(Send_field *tmp_field)
 
1038
void Item::make_field(SendField *tmp_field)
3919
1039
{
3920
1040
  init_make_field(tmp_field, field_type());
3921
1041
}
3922
1042
 
3923
 
 
3924
1043
enum_field_types Item::string_field_type() const
3925
1044
{
3926
1045
  enum_field_types f_type= DRIZZLE_TYPE_VARCHAR;
3929
1048
  return f_type;
3930
1049
}
3931
1050
 
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
1051
enum_field_types Item::field_type() const
3940
1052
{
3941
1053
  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;
 
1054
  case STRING_RESULT:  
 
1055
    return string_field_type();
 
1056
  case INT_RESULT:     
 
1057
    return DRIZZLE_TYPE_LONGLONG;
 
1058
  case DECIMAL_RESULT: 
 
1059
    return DRIZZLE_TYPE_DECIMAL;
 
1060
  case REAL_RESULT:    
 
1061
    return DRIZZLE_TYPE_DOUBLE;
3946
1062
  case ROW_RESULT:
3947
1063
  default:
3948
1064
    assert(0);
3950
1066
  }
3951
1067
}
3952
1068
 
3953
 
 
3954
1069
bool Item::is_datetime()
3955
1070
{
3956
1071
  switch (field_type())
3957
1072
  {
3958
 
    case DRIZZLE_TYPE_NEWDATE:
 
1073
    case DRIZZLE_TYPE_DATE:
3959
1074
    case DRIZZLE_TYPE_DATETIME:
3960
1075
    case DRIZZLE_TYPE_TIMESTAMP:
3961
1076
      return true;
3965
1080
  return false;
3966
1081
}
3967
1082
 
3968
 
 
3969
1083
String *Item::check_well_formed_result(String *str, bool send_error)
3970
1084
{
3971
1085
  /* Check whether we got a well-formed string */
3972
1086
  const CHARSET_INFO * const cs= str->charset();
3973
1087
  int well_formed_error;
3974
 
  uint wlen= cs->cset->well_formed_len(cs,
 
1088
  uint32_t wlen= cs->cset->well_formed_len(cs,
3975
1089
                                       str->ptr(), str->ptr() + str->length(),
3976
1090
                                       str->length(), &well_formed_error);
3977
1091
  if (wlen < str->length())
3978
1092
  {
3979
 
    THD *thd= current_thd;
 
1093
    Session *session= current_session;
3980
1094
    char hexbuf[7];
3981
1095
    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);
 
1096
    uint32_t diff= str->length() - wlen;
 
1097
    set_if_smaller(diff, 3U);
 
1098
    (void) drizzled_string_to_hex(hexbuf, str->ptr() + wlen, diff);
3985
1099
    if (send_error)
3986
1100
    {
3987
1101
      my_error(ER_INVALID_CHARACTER_STRING, MYF(0),
3988
1102
               cs->csname,  hexbuf);
3989
 
      return 0;
 
1103
      return NULL;
3990
1104
    }
3991
1105
    {
3992
1106
      level= DRIZZLE_ERROR::WARN_LEVEL_ERROR;
3993
1107
      null_value= 1;
3994
1108
      str= 0;
3995
1109
    }
3996
 
    push_warning_printf(thd, level, ER_INVALID_CHARACTER_STRING,
 
1110
    push_warning_printf(session, level, ER_INVALID_CHARACTER_STRING,
3997
1111
                        ER(ER_INVALID_CHARACTER_STRING), cs->csname, hexbuf);
3998
1112
  }
3999
1113
  return str;
4000
1114
}
4001
1115
 
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
1116
bool Item::eq_by_collation(Item *item, bool binary_cmp, const CHARSET_INFO * const cs)
4024
1117
{
4025
1118
  const CHARSET_INFO *save_cs= 0;
4040
1133
  if (save_item_cs)
4041
1134
    item->collation.collation= save_item_cs;
4042
1135
  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)
 
1136
}
 
1137
 
 
1138
Field *Item::make_string_field(Table *table)
4057
1139
{
4058
1140
  Field *field;
4059
1141
  assert(collation.collation);
4069
1151
  return field;
4070
1152
}
4071
1153
 
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)))
 
1154
Field *Item::tmp_table_field_from_field_type(Table *table, bool)
4086
1155
{
4087
1156
  /*
4088
1157
    The field functions defines a field to be not null if null_ptr is not 0
4089
1158
  */
4090
 
  uchar *null_ptr= maybe_null ? (uchar*) "" : 0;
 
1159
  unsigned char *null_ptr= maybe_null ? (unsigned char*) "" : 0;
4091
1160
  Field *field;
4092
1161
 
4093
1162
  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,
 
1163
  case DRIZZLE_TYPE_DECIMAL:
 
1164
    field= new Field_decimal((unsigned char*) 0,
 
1165
                                 max_length,
 
1166
                                 null_ptr,
 
1167
                                 0,
 
1168
                                 Field::NONE,
 
1169
                                 name,
 
1170
                                 decimals,
 
1171
                                 0,
4097
1172
                                 unsigned_flag);
4098
1173
    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
1174
  case DRIZZLE_TYPE_LONG:
4108
 
    field= new Field_long((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
 
1175
    field= new Field_long((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE,
4109
1176
                          name, 0, unsigned_flag);
4110
1177
    break;
4111
1178
  case DRIZZLE_TYPE_LONGLONG:
4112
 
    field= new Field_int64_t((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
 
1179
    field= new Field_int64_t((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE,
4113
1180
                              name, 0, unsigned_flag);
4114
1181
    break;
4115
1182
  case DRIZZLE_TYPE_DOUBLE:
4116
 
    field= new Field_double((uchar*) 0, max_length, null_ptr, 0, Field::NONE,
 
1183
    field= new Field_double((unsigned char*) 0, max_length, null_ptr, 0, Field::NONE,
4117
1184
                            name, decimals, 0, unsigned_flag);
4118
1185
    break;
4119
1186
  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);
 
1187
    field= new Field_null((unsigned char*) 0, max_length, name, &my_charset_bin);
 
1188
    break;
 
1189
  case DRIZZLE_TYPE_DATE:
 
1190
    field= new Field_date(maybe_null, name, &my_charset_bin);
4128
1191
    break;
4129
1192
  case DRIZZLE_TYPE_TIMESTAMP:
4130
1193
    field= new Field_timestamp(maybe_null, name, &my_charset_bin);
4152
1215
  return field;
4153
1216
}
4154
1217
 
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
1218
/*
4245
1219
  This implementation can lose str_value content, so if the
4246
1220
  Item uses str_value to store something, it should
4247
1221
  reimplement it's ::save_in_field() as Item_string, for example, does
4248
1222
*/
4249
 
 
4250
1223
int Item::save_in_field(Field *field, bool no_conversions)
4251
1224
{
4252
1225
  int error;
4306
1279
  return error;
4307
1280
}
4308
1281
 
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)
 
1282
/**
 
1283
  Check if an item is a constant one and can be cached.
 
1284
 
 
1285
  @param arg [out] TRUE <=> Cache this item.
 
1286
 
 
1287
  @return TRUE  Go deeper in item tree.
 
1288
  @return FALSE Don't go deeper in item tree.
 
1289
*/
 
1290
 
 
1291
bool Item::cache_const_expr_analyzer(unsigned char **arg)
 
1292
{
 
1293
  bool *cache_flag= (bool*)*arg;
 
1294
  if (!*cache_flag)
 
1295
  {
 
1296
    Item *item= real_item();
 
1297
    /*
 
1298
      Cache constant items unless it's a basic constant, constant field or
 
1299
      a subselect (they use their own cache).
 
1300
    */
 
1301
    if (const_item() &&
 
1302
        !(item->basic_const_item() || item->type() == Item::FIELD_ITEM ||
 
1303
          item->type() == SUBSELECT_ITEM ||
 
1304
           /*
 
1305
             Do not cache GET_USER_VAR() function as its const_item() may
 
1306
             return TRUE for the current thread but it still may change
 
1307
             during the execution.
 
1308
           */
 
1309
          (item->type() == Item::FUNC_ITEM &&
 
1310
           ((Item_func*)item)->functype() == Item_func::GUSERVAR_FUNC)))
 
1311
      *cache_flag= true;
 
1312
    return true;
 
1313
  }
 
1314
  return false;
 
1315
}
 
1316
 
 
1317
/**
 
1318
  Cache item if needed.
 
1319
 
 
1320
  @param arg   TRUE <=> Cache this item.
 
1321
 
 
1322
  @return cache if cache needed.
 
1323
  @return this otherwise.
 
1324
*/
 
1325
 
 
1326
Item* Item::cache_const_expr_transformer(unsigned char *arg)
 
1327
{
 
1328
  if (*(bool*)arg)
 
1329
  {
 
1330
    *((bool*)arg)= false;
 
1331
    Item_cache *cache= Item_cache::get_cache(this);
 
1332
    if (!cache)
 
1333
      return NULL;
 
1334
    cache->setup(this);
 
1335
    cache->store(this);
 
1336
    return cache;
 
1337
  }
 
1338
  return this;
 
1339
}
 
1340
 
 
1341
bool Item::send(plugin::Client *client, String *buffer)
4655
1342
{
4656
1343
  bool result= false;
4657
1344
  enum_field_types f_type;
4662
1349
  case DRIZZLE_TYPE_ENUM:
4663
1350
  case DRIZZLE_TYPE_BLOB:
4664
1351
  case DRIZZLE_TYPE_VARCHAR:
4665
 
  case DRIZZLE_TYPE_NEWDECIMAL:
 
1352
  case DRIZZLE_TYPE_DECIMAL:
4666
1353
  {
4667
1354
    String *res;
4668
1355
    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);
 
1356
      result= client->store(res->ptr(),res->length());
4686
1357
    break;
4687
1358
  }
4688
1359
  case DRIZZLE_TYPE_LONG:
4690
1361
    int64_t nr;
4691
1362
    nr= val_int();
4692
1363
    if (!null_value)
4693
 
      result= protocol->store_long(nr);
 
1364
      result= client->store((int32_t)nr);
4694
1365
    break;
4695
1366
  }
4696
1367
  case DRIZZLE_TYPE_LONGLONG:
4698
1369
    int64_t nr;
4699
1370
    nr= val_int();
4700
1371
    if (!null_value)
4701
 
      result= protocol->store_int64_t(nr, unsigned_flag);
 
1372
    {
 
1373
      if (unsigned_flag)
 
1374
        result= client->store((uint64_t)nr);
 
1375
      else
 
1376
        result= client->store((int64_t)nr);
 
1377
    }
4702
1378
    break;
4703
1379
  }
4704
1380
  case DRIZZLE_TYPE_DOUBLE:
4705
1381
  {
4706
1382
    double nr= val_real();
4707
1383
    if (!null_value)
4708
 
      result= protocol->store(nr, decimals, buffer);
 
1384
      result= client->store(nr, decimals, buffer);
4709
1385
    break;
4710
1386
  }
4711
1387
  case DRIZZLE_TYPE_DATETIME:
4714
1390
    DRIZZLE_TIME tm;
4715
1391
    get_date(&tm, TIME_FUZZY_DATE);
4716
1392
    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);
 
1393
      result= client->store(&tm);
4731
1394
    break;
4732
1395
  }
4733
1396
  }
4734
1397
  if (null_value)
4735
 
    result= protocol->store_null();
 
1398
    result= client->store();
4736
1399
  return result;
4737
1400
}
4738
1401
 
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
1402
Item_result item_cmp_type(Item_result a,Item_result b)
5723
1403
{
5724
1404
  if (a == STRING_RESULT && b == STRING_RESULT)
5733
1413
  return REAL_RESULT;
5734
1414
}
5735
1415
 
5736
 
 
5737
 
void resolve_const_item(THD *thd, Item **ref, Item *comp_item)
 
1416
void resolve_const_item(Session *session, Item **ref, Item *comp_item)
5738
1417
{
5739
1418
  Item *item= *ref;
5740
1419
  Item *new_item= NULL;
5741
1420
  if (item->basic_const_item())
5742
 
    return;                                     // Can't be better
 
1421
    return; /* Can't be better */
5743
1422
  Item_result res_type=item_cmp_type(comp_item->result_type(),
5744
1423
                                     item->result_type());
5745
 
  char *name=item->name;                        // Alloced by sql_alloc
 
1424
  char *name=item->name; /* Alloced by memory::sql_alloc */
5746
1425
 
5747
1426
  switch (res_type) {
5748
1427
  case STRING_RESULT:
5754
1433
      new_item= new Item_null(name);
5755
1434
    else
5756
1435
    {
5757
 
      uint length= result->length();
5758
 
      char *tmp_str= sql_strmake(result->ptr(), length);
 
1436
      uint32_t length= result->length();
 
1437
      char *tmp_str= memory::sql_strmake(result->ptr(), length);
5759
1438
      new_item= new Item_string(name, tmp_str, length, result->charset());
5760
1439
    }
5761
1440
    break;
5763
1442
  case INT_RESULT:
5764
1443
  {
5765
1444
    int64_t result=item->val_int();
5766
 
    uint length=item->max_length;
 
1445
    uint32_t length=item->max_length;
5767
1446
    bool null_value=item->null_value;
5768
1447
    new_item= (null_value ? (Item*) new Item_null(name) :
5769
1448
               (Item*) new Item_int(name, result, length));
5782
1461
    */
5783
1462
    Item_row *item_row= (Item_row*) item;
5784
1463
    Item_row *comp_item_row= (Item_row*) comp_item;
5785
 
    uint col;
 
1464
    uint32_t col;
5786
1465
    new_item= 0;
5787
1466
    /*
5788
1467
      If item and comp_item are both Item_rows and have same number of cols
5794
1473
    assert(item_row->cols() == comp_item_row->cols());
5795
1474
    col= item_row->cols();
5796
1475
    while (col-- > 0)
5797
 
      resolve_const_item(thd, item_row->addr(col),
 
1476
      resolve_const_item(session, item_row->addr(col),
5798
1477
                         comp_item_row->element_index(col));
5799
1478
    break;
5800
1479
  }
5802
1481
  case REAL_RESULT:
5803
1482
  {                                             // It must REAL_RESULT
5804
1483
    double result= item->val_real();
5805
 
    uint length=item->max_length,decimals=item->decimals;
 
1484
    uint32_t length=item->max_length,decimals=item->decimals;
5806
1485
    bool null_value=item->null_value;
5807
1486
    new_item= (null_value ? (Item*) new Item_null(name) : (Item*)
5808
1487
               new Item_float(name, result, decimals, length));
5812
1491
  {
5813
1492
    my_decimal decimal_value;
5814
1493
    my_decimal *result= item->val_decimal(&decimal_value);
5815
 
    uint length= item->max_length, decimals= item->decimals;
 
1494
    uint32_t length= item->max_length, decimals= item->decimals;
5816
1495
    bool null_value= item->null_value;
5817
1496
    new_item= (null_value ?
5818
1497
               (Item*) new Item_null(name) :
5823
1502
    assert(0);
5824
1503
  }
5825
1504
  if (new_item)
5826
 
    thd->change_item_tree(ref, new_item);
 
1505
    session->change_item_tree(ref, new_item);
5827
1506
}
5828
1507
 
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
1508
bool field_is_equal_to_item(Field *field,Item *item)
5838
1509
{
5839
1510
 
5869
1540
  return result == field->val_real();
5870
1541
}
5871
1542
 
5872
 
Item_cache* Item_cache::get_cache(const Item *item)
 
1543
void dummy_error_processor(Session *, void *)
 
1544
{}
 
1545
 
 
1546
/**
 
1547
  Create field for temporary table using type of given item.
 
1548
 
 
1549
  @param session                   Thread handler
 
1550
  @param item                  Item to create a field for
 
1551
  @param table                 Temporary table
 
1552
  @param copy_func             If set and item is a function, store copy of
 
1553
                               item in this array
 
1554
  @param modify_item           1 if item->result_field should point to new
 
1555
                               item. This is relevent for how fill_record()
 
1556
                               is going to work:
 
1557
                               If modify_item is 1 then fill_record() will
 
1558
                               update the record in the original table.
 
1559
                               If modify_item is 0 then fill_record() will
 
1560
                               update the temporary table
 
1561
  @param convert_blob_length   If >0 create a varstring(convert_blob_length)
 
1562
                               field instead of blob.
 
1563
 
 
1564
  @retval
 
1565
    0  on error
 
1566
  @retval
 
1567
    new_created field
 
1568
*/
 
1569
static Field *create_tmp_field_from_item(Session *,
 
1570
                                         Item *item, Table *table,
 
1571
                                         Item ***copy_func, bool modify_item,
 
1572
                                         uint32_t convert_blob_length)
5873
1573
{
 
1574
  bool maybe_null= item->maybe_null;
 
1575
  Field *new_field;
 
1576
 
5874
1577
  switch (item->result_type()) {
 
1578
  case REAL_RESULT:
 
1579
    new_field= new Field_double(item->max_length, maybe_null,
 
1580
                                item->name, item->decimals, true);
 
1581
    break;
5875
1582
  case INT_RESULT:
5876
 
    return new Item_cache_int();
5877
 
  case REAL_RESULT:
5878
 
    return new Item_cache_real();
 
1583
    /*
 
1584
      Select an integer type with the minimal fit precision.
 
1585
      MY_INT32_NUM_DECIMAL_DIGITS is sign inclusive, don't consider the sign.
 
1586
      Values with MY_INT32_NUM_DECIMAL_DIGITS digits may or may not fit into
 
1587
      Field_long : make them Field_int64_t.
 
1588
    */
 
1589
    if (item->max_length >= (MY_INT32_NUM_DECIMAL_DIGITS - 1))
 
1590
      new_field=new Field_int64_t(item->max_length, maybe_null,
 
1591
                                   item->name, item->unsigned_flag);
 
1592
    else
 
1593
      new_field=new Field_long(item->max_length, maybe_null,
 
1594
                               item->name, item->unsigned_flag);
 
1595
    break;
 
1596
  case STRING_RESULT:
 
1597
    assert(item->collation.collation);
 
1598
 
 
1599
    enum enum_field_types type;
 
1600
    /*
 
1601
      DATE/TIME fields have STRING_RESULT result type.
 
1602
      To preserve type they needed to be handled separately.
 
1603
    */
 
1604
    if ((type= item->field_type()) == DRIZZLE_TYPE_DATETIME ||
 
1605
        type == DRIZZLE_TYPE_DATE ||
 
1606
        type == DRIZZLE_TYPE_TIMESTAMP)
 
1607
      new_field= item->tmp_table_field_from_field_type(table, 1);
 
1608
    /*
 
1609
      Make sure that the blob fits into a Field_varstring which has
 
1610
      2-byte lenght.
 
1611
    */
 
1612
    else if (item->max_length/item->collation.collation->mbmaxlen > 255 &&
 
1613
             convert_blob_length <= Field_varstring::MAX_SIZE &&
 
1614
             convert_blob_length)
 
1615
      new_field= new Field_varstring(convert_blob_length, maybe_null,
 
1616
                                     item->name, table->s,
 
1617
                                     item->collation.collation);
 
1618
    else
 
1619
      new_field= item->make_string_field(table);
 
1620
    new_field->set_derivation(item->collation.derivation);
 
1621
    break;
5879
1622
  case DECIMAL_RESULT:
5880
 
    return new Item_cache_decimal();
5881
 
  case STRING_RESULT:
5882
 
    return new Item_cache_str(item);
 
1623
  {
 
1624
    uint8_t dec= item->decimals;
 
1625
    uint8_t intg= ((Item_decimal *) item)->decimal_precision() - dec;
 
1626
    uint32_t len= item->max_length;
 
1627
 
 
1628
    /*
 
1629
      Trying to put too many digits overall in a DECIMAL(prec,dec)
 
1630
      will always throw a warning. We must limit dec to
 
1631
      DECIMAL_MAX_SCALE however to prevent an assert() later.
 
1632
    */
 
1633
 
 
1634
    if (dec > 0)
 
1635
    {
 
1636
      signed int overflow;
 
1637
 
 
1638
      dec= min(dec, (uint8_t)DECIMAL_MAX_SCALE);
 
1639
 
 
1640
      /*
 
1641
        If the value still overflows the field with the corrected dec,
 
1642
        we'll throw out decimals rather than integers. This is still
 
1643
        bad and of course throws a truncation warning.
 
1644
        +1: for decimal point
 
1645
      */
 
1646
 
 
1647
      overflow= my_decimal_precision_to_length(intg + dec, dec,
 
1648
                                               item->unsigned_flag) - len;
 
1649
 
 
1650
      if (overflow > 0)
 
1651
        dec= max(0, dec - overflow);            // too long, discard fract
 
1652
      else
 
1653
        len-= item->decimals - dec;             // corrected value fits
 
1654
    }
 
1655
 
 
1656
    new_field= new Field_decimal(len,
 
1657
                                 maybe_null,
 
1658
                                 item->name,
 
1659
                                 dec,
 
1660
                                 item->unsigned_flag);
 
1661
    break;
 
1662
  }
5883
1663
  case ROW_RESULT:
5884
 
    return new Item_cache_row();
5885
1664
  default:
5886
 
    // should never be in real life
 
1665
    // This case should never be choosen
5887
1666
    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
 
*****************************************************************************/
6508
 
 
6509
 
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
6510
 
template class List<Item>;
6511
 
template class List_iterator<Item>;
6512
 
template class List_iterator_fast<Item>;
6513
 
template class List_iterator_fast<Item_field>;
6514
 
template class List<List_item>;
6515
 
#endif
 
1667
    new_field= 0;
 
1668
    break;
 
1669
  }
 
1670
  if (new_field)
 
1671
    new_field->init(table);
 
1672
 
 
1673
  if (copy_func && item->is_result_field())
 
1674
    *((*copy_func)++) = item;                   // Save for copy_funcs
 
1675
  if (modify_item)
 
1676
    item->set_result_field(new_field);
 
1677
  if (item->type() == Item::NULL_ITEM)
 
1678
    new_field->is_created_from_null_item= true;
 
1679
  return new_field;
 
1680
}
 
1681
 
 
1682
Field *create_tmp_field(Session *session,
 
1683
                        Table *table,
 
1684
                        Item *item,
 
1685
                        Item::Type type, 
 
1686
                        Item ***copy_func, 
 
1687
                        Field **from_field,
 
1688
                        Field **default_field, 
 
1689
                        bool group, 
 
1690
                        bool modify_item,
 
1691
                        bool, 
 
1692
                        bool make_copy_field,
 
1693
                        uint32_t convert_blob_length)
 
1694
{
 
1695
  Field *result;
 
1696
  Item::Type orig_type= type;
 
1697
  Item *orig_item= 0;
 
1698
 
 
1699
  if (type != Item::FIELD_ITEM &&
 
1700
      item->real_item()->type() == Item::FIELD_ITEM)
 
1701
  {
 
1702
    orig_item= item;
 
1703
    item= item->real_item();
 
1704
    type= Item::FIELD_ITEM;
 
1705
  }
 
1706
 
 
1707
  switch (type) {
 
1708
  case Item::SUM_FUNC_ITEM:
 
1709
  {
 
1710
    Item_sum *item_sum=(Item_sum*) item;
 
1711
    result= item_sum->create_tmp_field(group, table, convert_blob_length);
 
1712
    if (!result)
 
1713
      my_error(ER_OUT_OF_RESOURCES, MYF(ME_FATALERROR));
 
1714
    return result;
 
1715
  }
 
1716
  case Item::FIELD_ITEM:
 
1717
  case Item::DEFAULT_VALUE_ITEM:
 
1718
  {
 
1719
    Item_field *field= (Item_field*) item;
 
1720
    bool orig_modify= modify_item;
 
1721
    if (orig_type == Item::REF_ITEM)
 
1722
      modify_item= 0;
 
1723
    /*
 
1724
      If item have to be able to store NULLs but underlaid field can't do it,
 
1725
      create_tmp_field_from_field() can't be used for tmp field creation.
 
1726
    */
 
1727
    if (field->maybe_null && !field->field->maybe_null())
 
1728
    {
 
1729
      result= create_tmp_field_from_item(session, item, table, NULL,
 
1730
                                         modify_item, convert_blob_length);
 
1731
      *from_field= field->field;
 
1732
      if (result && modify_item)
 
1733
        field->result_field= result;
 
1734
    }
 
1735
    else
 
1736
      result= create_tmp_field_from_field(session, (*from_field= field->field),
 
1737
                                          orig_item ? orig_item->name :
 
1738
                                          item->name,
 
1739
                                          table,
 
1740
                                          modify_item ? field :
 
1741
                                          NULL,
 
1742
                                          convert_blob_length);
 
1743
    if (orig_type == Item::REF_ITEM && orig_modify)
 
1744
      ((Item_ref*)orig_item)->set_result_field(result);
 
1745
    if (field->field->eq_def(result))
 
1746
      *default_field= field->field;
 
1747
    return result;
 
1748
  }
 
1749
  /* Fall through */
 
1750
  case Item::FUNC_ITEM:
 
1751
    /* Fall through */
 
1752
  case Item::COND_ITEM:
 
1753
  case Item::FIELD_AVG_ITEM:
 
1754
  case Item::FIELD_STD_ITEM:
 
1755
  case Item::SUBSELECT_ITEM:
 
1756
    /* The following can only happen with 'CREATE TABLE ... SELECT' */
 
1757
  case Item::PROC_ITEM:
 
1758
  case Item::INT_ITEM:
 
1759
  case Item::REAL_ITEM:
 
1760
  case Item::DECIMAL_ITEM:
 
1761
  case Item::STRING_ITEM:
 
1762
  case Item::REF_ITEM:
 
1763
  case Item::NULL_ITEM:
 
1764
  case Item::VARBIN_ITEM:
 
1765
    if (make_copy_field)
 
1766
    {
 
1767
      assert(((Item_result_field*)item)->result_field);
 
1768
      *from_field= ((Item_result_field*)item)->result_field;
 
1769
    }
 
1770
    return create_tmp_field_from_item(session, item, table,
 
1771
                                      (make_copy_field ? 0 : copy_func),
 
1772
                                       modify_item, convert_blob_length);
 
1773
  case Item::TYPE_HOLDER:
 
1774
    result= ((Item_type_holder *)item)->make_field_by_type(table);
 
1775
    result->set_derivation(item->collation.derivation);
 
1776
    return result;
 
1777
  default:                                      // Dosen't have to be stored
 
1778
    return NULL;
 
1779
  }
 
1780
}
 
1781