← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/field.cc

  • Committer: Brian Aker
  • Date: 2008-10-12 01:59:02 UTC
  • Revision ID: brian@tangent.org-20081012015902-prhy6wsimdqr28om
Dead code around unsigned (first pass)

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/field.cc
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
19
 
 
20
 
#include "config.h"
21
 
 
22
 
#include <drizzled/session.h>
23
 
#include <drizzled/table.h>
24
 
#include <drizzled/error.h>
25
 
#include <drizzled/join.h>
26
 
#include <drizzled/sql_base.h>
27
 
#include <drizzled/sql_select.h>
28
 
#include <drizzled/item/cmpfunc.h>
29
 
#include <drizzled/item/field.h>
30
 
#include <drizzled/item/outer_ref.h>
31
 
#include <drizzled/plugin/client.h>
32
 
 
33
 
#include <boost/dynamic_bitset.hpp>
34
 
 
35
 
namespace drizzled
36
 
{
37
 
 
38
 
/**
39
 
  Store the pointer to this item field into a list if not already there.
40
 
 
41
 
  The method is used by Item::walk to collect all unique Item_field objects
42
 
  from a tree of Items into a set of items represented as a list.
43
 
 
44
 
  Item_cond::walk() and Item_func::walk() stop the evaluation of the
45
 
  processor function for its arguments once the processor returns
46
 
  true.Therefore in order to force this method being called for all item
47
 
  arguments in a condition the method must return false.
48
 
 
49
 
  @param arg  pointer to a List<Item_field>
50
 
 
51
 
  @return
52
 
    false to force the evaluation of collect_item_field_processor
53
 
    for the subsequent items.
54
 
*/
55
 
 
56
 
bool Item_field::collect_item_field_processor(unsigned char *arg)
57
 
{
58
 
  List<Item_field> *item_list= (List<Item_field>*) arg;
59
 
  List_iterator<Item_field> item_list_it(*item_list);
60
 
  Item_field *curr_item;
61
 
  while ((curr_item= item_list_it++))
62
 
  {
63
 
    if (curr_item->eq(this, 1))
64
 
      return(false); /* Already in the set. */
65
 
  }
66
 
  item_list->push_back(this);
67
 
  return(false);
68
 
}
69
 
 
70
 
 
71
 
/**
72
 
  Check if an Item_field references some field from a list of fields.
73
 
 
74
 
  Check whether the Item_field represented by 'this' references any
75
 
  of the fields in the keyparts passed via 'arg'. Used with the
76
 
  method Item::walk() to test whether any keypart in a sequence of
77
 
  keyparts is referenced in an expression.
78
 
 
79
 
  @param arg   Field being compared, arg must be of type Field
80
 
 
81
 
  @retval
82
 
    true  if 'this' references the field 'arg'
83
 
  @retval
84
 
    false otherwise
85
 
*/
86
 
 
87
 
bool Item_field::find_item_in_field_list_processor(unsigned char *arg)
88
 
{
89
 
  KeyPartInfo *first_non_group_part= *((KeyPartInfo **) arg);
90
 
  KeyPartInfo *last_part= *(((KeyPartInfo **) arg) + 1);
91
 
  KeyPartInfo *cur_part;
92
 
 
93
 
  for (cur_part= first_non_group_part; cur_part != last_part; cur_part++)
94
 
  {
95
 
    if (field->eq(cur_part->field))
96
 
      return true;
97
 
  }
98
 
  return false;
99
 
}
100
 
 
101
 
 
102
 
/*
103
 
  Mark field in read_map
104
 
 
105
 
  NOTES
106
 
    This is used by filesort to register used fields in a a temporary
107
 
    column read set or to register used fields in a view
108
 
*/
109
 
 
110
 
bool Item_field::register_field_in_read_map(unsigned char *arg)
111
 
{
112
 
  Table *table= (Table *) arg;
113
 
  if (field->getTable() == table || !table)
114
 
    field->getTable()->setReadSet(field->position());
115
 
 
116
 
  return 0;
117
 
}
118
 
 
119
 
 
120
 
Item_field::Item_field(Field *f)
121
 
  :Item_ident(0, NULL, f->getTable()->getAlias(), f->field_name),
122
 
   item_equal(0), no_const_subst(0),
123
 
   have_privileges(0), any_privileges(0)
124
 
{
125
 
  set_field(f);
126
 
  /*
127
 
    field_name and table_name should not point to garbage
128
 
    if this item is to be reused
129
 
  */
130
 
  orig_table_name= orig_field_name= "";
131
 
}
132
 
 
133
 
 
134
 
/**
135
 
  Constructor used inside setup_wild().
136
 
 
137
 
  Ensures that field, table, and database names will live as long as
138
 
  Item_field (this is important in prepared statements).
139
 
*/
140
 
 
141
 
Item_field::Item_field(Session *,
142
 
                       Name_resolution_context *context_arg,
143
 
                       Field *f) :
144
 
  Item_ident(context_arg,
145
 
             f->getTable()->getShare()->getSchemaName(),
146
 
             f->getTable()->getAlias(),
147
 
             f->field_name),
148
 
   item_equal(0),
149
 
   no_const_subst(0),
150
 
   have_privileges(0),
151
 
   any_privileges(0)
152
 
{
153
 
  set_field(f);
154
 
}
155
 
 
156
 
 
157
 
Item_field::Item_field(Name_resolution_context *context_arg,
158
 
                       const char *db_arg,const char *table_name_arg,
159
 
                       const char *field_name_arg) :
160
 
  Item_ident(context_arg, db_arg,table_name_arg,field_name_arg),
161
 
   field(0),
162
 
   result_field(0),
163
 
   item_equal(0),
164
 
   no_const_subst(0),
165
 
   have_privileges(0),
166
 
   any_privileges(0)
167
 
{
168
 
  Select_Lex *select= current_session->lex->current_select;
169
 
  collation.set(DERIVATION_IMPLICIT);
170
 
 
171
 
  if (select && select->parsing_place != IN_HAVING)
172
 
      select->select_n_where_fields++;
173
 
}
174
 
 
175
 
/**
176
 
  Constructor need to process subselect with temporary tables (see Item)
177
 
*/
178
 
 
179
 
Item_field::Item_field(Session *session, Item_field *item) :
180
 
  Item_ident(session, item),
181
 
  field(item->field),
182
 
  result_field(item->result_field),
183
 
  item_equal(item->item_equal),
184
 
  no_const_subst(item->no_const_subst),
185
 
  have_privileges(item->have_privileges),
186
 
  any_privileges(item->any_privileges)
187
 
{
188
 
  collation.set(DERIVATION_IMPLICIT);
189
 
}
190
 
 
191
 
void Item_field::set_field(Field *field_par)
192
 
{
193
 
  field=result_field=field_par;                 // for easy coding with fields
194
 
  maybe_null=field->maybe_null();
195
 
  decimals= field->decimals();
196
 
  max_length= field_par->max_display_length();
197
 
  table_name= field_par->getTable()->getAlias();
198
 
  field_name= field_par->field_name;
199
 
  db_name= field_par->getTable()->getShare()->getSchemaName();
200
 
  alias_name_used= field_par->getTable()->alias_name_used;
201
 
  unsigned_flag=test(field_par->flags & UNSIGNED_FLAG);
202
 
  collation.set(field_par->charset(), field_par->derivation());
203
 
  fixed= 1;
204
 
}
205
 
 
206
 
 
207
 
/**
208
 
  Reset this item to point to a field from the new temporary table.
209
 
  This is used when we create a new temporary table for each execution
210
 
  of prepared statement.
211
 
*/
212
 
 
213
 
void Item_field::reset_field(Field *f)
214
 
{
215
 
  set_field(f);
216
 
  /* 'name' is pointing at field->field_name of old field */
217
 
  name= (char*) f->field_name;
218
 
}
219
 
 
220
 
/* ARGSUSED */
221
 
String *Item_field::val_str(String *str)
222
 
{
223
 
  assert(fixed == 1);
224
 
  if ((null_value=field->is_null()))
225
 
    return 0;
226
 
  str->set_charset(str_value.charset());
227
 
  return field->val_str(str,&str_value);
228
 
}
229
 
 
230
 
 
231
 
double Item_field::val_real()
232
 
{
233
 
  assert(fixed == 1);
234
 
  if ((null_value=field->is_null()))
235
 
    return 0.0;
236
 
  return field->val_real();
237
 
}
238
 
 
239
 
 
240
 
int64_t Item_field::val_int()
241
 
{
242
 
  assert(fixed == 1);
243
 
  if ((null_value=field->is_null()))
244
 
    return 0;
245
 
  return field->val_int();
246
 
}
247
 
 
248
 
 
249
 
my_decimal *Item_field::val_decimal(my_decimal *decimal_value)
250
 
{
251
 
  if ((null_value= field->is_null()))
252
 
    return 0;
253
 
  return field->val_decimal(decimal_value);
254
 
}
255
 
 
256
 
 
257
 
String *Item_field::str_result(String *str)
258
 
{
259
 
  if ((null_value=result_field->is_null()))
260
 
    return 0;
261
 
  str->set_charset(str_value.charset());
262
 
  return result_field->val_str(str,&str_value);
263
 
}
264
 
 
265
 
bool Item_field::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
266
 
{
267
 
  if ((null_value=field->is_null()) || field->get_date(ltime,fuzzydate))
268
 
  {
269
 
    memset(ltime, 0, sizeof(*ltime));
270
 
    return 1;
271
 
  }
272
 
  return 0;
273
 
}
274
 
 
275
 
bool Item_field::get_date_result(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
276
 
{
277
 
  if ((null_value=result_field->is_null()) ||
278
 
      result_field->get_date(ltime,fuzzydate))
279
 
  {
280
 
    memset(ltime, 0, sizeof(*ltime));
281
 
    return 1;
282
 
  }
283
 
  return 0;
284
 
}
285
 
 
286
 
bool Item_field::get_time(DRIZZLE_TIME *ltime)
287
 
{
288
 
  if ((null_value=field->is_null()) || field->get_time(ltime))
289
 
  {
290
 
    memset(ltime, 0, sizeof(*ltime));
291
 
    return 1;
292
 
  }
293
 
  return 0;
294
 
}
295
 
 
296
 
double Item_field::val_result()
297
 
{
298
 
  if ((null_value=result_field->is_null()))
299
 
    return 0.0;
300
 
  return result_field->val_real();
301
 
}
302
 
 
303
 
int64_t Item_field::val_int_result()
304
 
{
305
 
  if ((null_value=result_field->is_null()))
306
 
    return 0;
307
 
  return result_field->val_int();
308
 
}
309
 
 
310
 
 
311
 
my_decimal *Item_field::val_decimal_result(my_decimal *decimal_value)
312
 
{
313
 
  if ((null_value= result_field->is_null()))
314
 
    return 0;
315
 
  return result_field->val_decimal(decimal_value);
316
 
}
317
 
 
318
 
 
319
 
bool Item_field::val_bool_result()
320
 
{
321
 
  if ((null_value= result_field->is_null()))
322
 
    return false;
323
 
  switch (result_field->result_type()) {
324
 
  case INT_RESULT:
325
 
    return result_field->val_int() != 0;
326
 
 
327
 
  case DECIMAL_RESULT:
328
 
    {
329
 
      my_decimal decimal_value;
330
 
      my_decimal *val= result_field->val_decimal(&decimal_value);
331
 
      if (val)
332
 
        return !my_decimal_is_zero(val);
333
 
      return 0;
334
 
    }
335
 
 
336
 
  case REAL_RESULT:
337
 
  case STRING_RESULT:
338
 
    return result_field->val_real() != 0.0;
339
 
 
340
 
  case ROW_RESULT:
341
 
    assert(0);
342
 
    return 0;                                   // Shut up compiler
343
 
  }
344
 
 
345
 
  assert(0);
346
 
  return 0;                                   // Shut up compiler
347
 
}
348
 
 
349
 
 
350
 
bool Item_field::eq(const Item *item, bool) const
351
 
{
352
 
  const Item *item_ptr= item->real_item();
353
 
  if (item_ptr->type() != FIELD_ITEM)
354
 
    return 0;
355
 
 
356
 
  const Item_field *item_field= static_cast<const Item_field *>(item_ptr);
357
 
  if (item_field->field && field)
358
 
    return item_field->field == field;
359
 
  /*
360
 
    We may come here when we are trying to find a function in a GROUP BY
361
 
    clause from the select list.
362
 
    In this case the '100 % correct' way to do this would be to first
363
 
    run fix_fields() on the GROUP BY item and then retry this function, but
364
 
    I think it's better to relax the checking a bit as we will in
365
 
    most cases do the correct thing by just checking the field name.
366
 
    (In cases where we would choose wrong we would have to generate a
367
 
    ER_NON_UNIQ_ERROR).
368
 
  */
369
 
  return (!my_strcasecmp(system_charset_info, item_field->name,
370
 
                         field_name) &&
371
 
          (!item_field->table_name || !table_name ||
372
 
           (!my_strcasecmp(table_alias_charset, item_field->table_name,
373
 
                           table_name) &&
374
 
            (!item_field->db_name || !db_name ||
375
 
             (item_field->db_name && !strcasecmp(item_field->db_name,
376
 
                                             db_name))))));
377
 
}
378
 
 
379
 
 
380
 
table_map Item_field::used_tables() const
381
 
{
382
 
  if (field->getTable()->const_table)
383
 
    return 0;                                   // const item
384
 
  return (depended_from ? OUTER_REF_TABLE_BIT : field->getTable()->map);
385
 
}
386
 
 
387
 
enum Item_result Item_field::result_type () const
388
 
{
389
 
  return field->result_type();
390
 
}
391
 
 
392
 
 
393
 
Item_result Item_field::cast_to_int_type() const
394
 
{
395
 
  return field->cast_to_int_type();
396
 
}
397
 
 
398
 
 
399
 
enum_field_types Item_field::field_type() const
400
 
{
401
 
  return field->type();
402
 
}
403
 
 
404
 
 
405
 
void Item_field::fix_after_pullout(Select_Lex *new_parent, Item **)
406
 
{
407
 
  if (new_parent == depended_from)
408
 
    depended_from= NULL;
409
 
  Name_resolution_context *ctx= new Name_resolution_context();
410
 
  ctx->outer_context= NULL; // We don't build a complete name resolver
411
 
  ctx->select_lex= new_parent;
412
 
  ctx->first_name_resolution_table= context->first_name_resolution_table;
413
 
  ctx->last_name_resolution_table=  context->last_name_resolution_table;
414
 
  this->context=ctx;
415
 
}
416
 
 
417
 
 
418
 
bool Item_field::is_null()
419
 
{
420
 
  return field->is_null();
421
 
}
422
 
 
423
 
 
424
 
Item *Item_field::get_tmp_table_item(Session *session)
425
 
{
426
 
  Item_field *new_item= new Item_field(session, this);
427
 
  if (new_item)
428
 
    new_item->field= new_item->result_field;
429
 
  return new_item;
430
 
}
431
 
 
432
 
int64_t Item_field::val_int_endpoint(bool, bool *)
433
 
{
434
 
  int64_t res= val_int();
435
 
  return null_value? INT64_MIN : res;
436
 
}
437
 
 
438
 
 
439
 
/**
440
 
  Resolve the name of an outer select column reference.
441
 
 
442
 
  The method resolves the column reference represented by 'this' as a column
443
 
  present in outer selects that contain current select.
444
 
 
445
 
  In prepared statements, because of cache, find_field_in_tables()
446
 
  can resolve fields even if they don't belong to current context.
447
 
  In this case this method only finds appropriate context and marks
448
 
  current select as dependent. The found reference of field should be
449
 
  provided in 'from_field'.
450
 
 
451
 
  @param[in] session             current thread
452
 
  @param[in,out] from_field  found field reference or (Field*)not_found_field
453
 
  @param[in,out] reference   view column if this item was resolved to a
454
 
    view column
455
 
 
456
 
  @note
457
 
    This is the inner loop of Item_field::fix_fields:
458
 
  @code
459
 
        for each outer query Q_k beginning from the inner-most one
460
 
        {
461
 
          search for a column or derived column named col_ref_i
462
 
          [in table T_j] in the FROM clause of Q_k;
463
 
 
464
 
          if such a column is not found
465
 
            Search for a column or derived column named col_ref_i
466
 
            [in table T_j] in the SELECT and GROUP clauses of Q_k.
467
 
        }
468
 
  @endcode
469
 
 
470
 
  @retval
471
 
    1   column succefully resolved and fix_fields() should continue.
472
 
  @retval
473
 
    0   column fully fixed and fix_fields() should return false
474
 
  @retval
475
 
    -1  error occured
476
 
*/
477
 
 
478
 
int
479
 
Item_field::fix_outer_field(Session *session, Field **from_field, Item **reference)
480
 
{
481
 
  enum_parsing_place place= NO_MATTER;
482
 
  bool field_found= (*from_field != not_found_field);
483
 
  bool upward_lookup= false;
484
 
 
485
 
  /*
486
 
    If there are outer contexts (outer selects, but current select is
487
 
    not derived table or view) try to resolve this reference in the
488
 
    outer contexts.
489
 
 
490
 
    We treat each subselect as a separate namespace, so that different
491
 
    subselects may contain columns with the same names. The subselects
492
 
    are searched starting from the innermost.
493
 
  */
494
 
  Name_resolution_context *last_checked_context= context;
495
 
  Item **ref= (Item **) not_found_item;
496
 
  Select_Lex *current_sel= (Select_Lex *) session->lex->current_select;
497
 
  Name_resolution_context *outer_context= 0;
498
 
  Select_Lex *select= 0;
499
 
  /* Currently derived tables cannot be correlated */
500
 
  if (current_sel->master_unit()->first_select()->linkage !=
501
 
      DERIVED_TABLE_TYPE)
502
 
    outer_context= context->outer_context;
503
 
  for (;
504
 
       outer_context;
505
 
       outer_context= outer_context->outer_context)
506
 
  {
507
 
    select= outer_context->select_lex;
508
 
    Item_subselect *prev_subselect_item=
509
 
      last_checked_context->select_lex->master_unit()->item;
510
 
    last_checked_context= outer_context;
511
 
    upward_lookup= true;
512
 
 
513
 
    place= prev_subselect_item->parsing_place;
514
 
    /*
515
 
      If outer_field is set, field was already found by first call
516
 
      to find_field_in_tables(). Only need to find appropriate context.
517
 
    */
518
 
    if (field_found && outer_context->select_lex !=
519
 
        cached_table->select_lex)
520
 
      continue;
521
 
    /*
522
 
      In case of a view, find_field_in_tables() writes the pointer to
523
 
      the found view field into '*reference', in other words, it
524
 
      substitutes this Item_field with the found expression.
525
 
    */
526
 
    if (field_found || (*from_field= find_field_in_tables(session, this,
527
 
                                          outer_context->
528
 
                                            first_name_resolution_table,
529
 
                                          outer_context->
530
 
                                            last_name_resolution_table,
531
 
                                          reference,
532
 
                                          IGNORE_EXCEPT_NON_UNIQUE,
533
 
                                          true)) !=
534
 
        not_found_field)
535
 
    {
536
 
      if (*from_field)
537
 
      {
538
 
        if (*from_field != view_ref_found)
539
 
        {
540
 
          prev_subselect_item->used_tables_cache|= (*from_field)->getTable()->map;
541
 
          prev_subselect_item->const_item_cache= 0;
542
 
          set_field(*from_field);
543
 
          if (!last_checked_context->select_lex->having_fix_field &&
544
 
              select->group_list.elements &&
545
 
              (place == SELECT_LIST || place == IN_HAVING))
546
 
          {
547
 
            Item_outer_ref *rf;
548
 
            /*
549
 
              If an outer field is resolved in a grouping select then it
550
 
              is replaced for an Item_outer_ref object. Otherwise an
551
 
              Item_field object is used.
552
 
              The new Item_outer_ref object is saved in the inner_refs_list of
553
 
              the outer select. Here it is only created. It can be fixed only
554
 
              after the original field has been fixed and this is done in the
555
 
              fix_inner_refs() function.
556
 
            */
557
 
            ;
558
 
            if (!(rf= new Item_outer_ref(context, this)))
559
 
              return -1;
560
 
            session->change_item_tree(reference, rf);
561
 
            select->inner_refs_list.push_back(rf);
562
 
            rf->in_sum_func= session->lex->in_sum_func;
563
 
          }
564
 
          /*
565
 
            A reference is resolved to a nest level that's outer or the same as
566
 
            the nest level of the enclosing set function : adjust the value of
567
 
            max_arg_level for the function if it's needed.
568
 
          */
569
 
          if (session->lex->in_sum_func &&
570
 
              session->lex->in_sum_func->nest_level >= select->nest_level)
571
 
          {
572
 
            Item::Type ref_type= (*reference)->type();
573
 
            set_if_bigger(session->lex->in_sum_func->max_arg_level,
574
 
                          select->nest_level);
575
 
            set_field(*from_field);
576
 
            fixed= 1;
577
 
            mark_as_dependent(session, last_checked_context->select_lex,
578
 
                              context->select_lex, this,
579
 
                              ((ref_type == REF_ITEM ||
580
 
                                ref_type == FIELD_ITEM) ?
581
 
                               (Item_ident*) (*reference) : 0));
582
 
            return 0;
583
 
          }
584
 
        }
585
 
        else
586
 
        {
587
 
          Item::Type ref_type= (*reference)->type();
588
 
          prev_subselect_item->used_tables_cache|=
589
 
            (*reference)->used_tables();
590
 
          prev_subselect_item->const_item_cache&=
591
 
            (*reference)->const_item();
592
 
          mark_as_dependent(session, last_checked_context->select_lex,
593
 
                            context->select_lex, this,
594
 
                            ((ref_type == REF_ITEM || ref_type == FIELD_ITEM) ?
595
 
                             (Item_ident*) (*reference) :
596
 
                             0));
597
 
          /*
598
 
            A reference to a view field had been found and we
599
 
            substituted it instead of this Item (find_field_in_tables
600
 
            does it by assigning the new value to *reference), so now
601
 
            we can return from this function.
602
 
          */
603
 
          return 0;
604
 
        }
605
 
      }
606
 
      break;
607
 
    }
608
 
 
609
 
    /* Search in SELECT and GROUP lists of the outer select. */
610
 
    if (place != IN_WHERE && place != IN_ON)
611
 
    {
612
 
      if (!(ref= resolve_ref_in_select_and_group(session, this, select)))
613
 
        return -1; /* Some error occurred (e.g. ambiguous names). */
614
 
      if (ref != not_found_item)
615
 
      {
616
 
        assert(*ref && (*ref)->fixed);
617
 
        prev_subselect_item->used_tables_cache|= (*ref)->used_tables();
618
 
        prev_subselect_item->const_item_cache&= (*ref)->const_item();
619
 
        break;
620
 
      }
621
 
    }
622
 
 
623
 
    /*
624
 
      Reference is not found in this select => this subquery depend on
625
 
      outer select (or we just trying to find wrong identifier, in this
626
 
      case it does not matter which used tables bits we set)
627
 
    */
628
 
    prev_subselect_item->used_tables_cache|= OUTER_REF_TABLE_BIT;
629
 
    prev_subselect_item->const_item_cache= 0;
630
 
  }
631
 
 
632
 
  assert(ref != 0);
633
 
  if (!*from_field)
634
 
    return -1;
635
 
  if (ref == not_found_item && *from_field == not_found_field)
636
 
  {
637
 
    if (upward_lookup)
638
 
    {
639
 
      // We can't say exactly what absent table or field
640
 
      my_error(ER_BAD_FIELD_ERROR, MYF(0), full_name(), session->where);
641
 
    }
642
 
    else
643
 
    {
644
 
      /* Call find_field_in_tables only to report the error */
645
 
      find_field_in_tables(session, this,
646
 
                           context->first_name_resolution_table,
647
 
                           context->last_name_resolution_table,
648
 
                           reference, REPORT_ALL_ERRORS, true);
649
 
    }
650
 
    return -1;
651
 
  }
652
 
  else if (ref != not_found_item)
653
 
  {
654
 
    Item *save;
655
 
    Item_ref *rf;
656
 
 
657
 
    /* Should have been checked in resolve_ref_in_select_and_group(). */
658
 
    assert(*ref && (*ref)->fixed);
659
 
    /*
660
 
      Here, a subset of actions performed by Item_ref::set_properties
661
 
      is not enough. So we pass ptr to NULL into Item_[direct]_ref
662
 
      constructor, so no initialization is performed, and call
663
 
      fix_fields() below.
664
 
    */
665
 
    save= *ref;
666
 
    *ref= NULL;                             // Don't call set_properties()
667
 
    rf= (place == IN_HAVING ?
668
 
         new Item_ref(context, ref, (char*) table_name,
669
 
                      (char*) field_name, alias_name_used) :
670
 
         (!select->group_list.elements ?
671
 
         new Item_direct_ref(context, ref, (char*) table_name,
672
 
                             (char*) field_name, alias_name_used) :
673
 
         new Item_outer_ref(context, ref, (char*) table_name,
674
 
                            (char*) field_name, alias_name_used)));
675
 
    *ref= save;
676
 
    if (!rf)
677
 
      return -1;
678
 
 
679
 
    if (place != IN_HAVING && select->group_list.elements)
680
 
    {
681
 
      outer_context->select_lex->inner_refs_list.push_back((Item_outer_ref*)rf);
682
 
      ((Item_outer_ref*)rf)->in_sum_func= session->lex->in_sum_func;
683
 
    }
684
 
    session->change_item_tree(reference, rf);
685
 
    /*
686
 
      rf is Item_ref => never substitute other items (in this case)
687
 
      during fix_fields() => we can use rf after fix_fields()
688
 
    */
689
 
    assert(!rf->fixed);                // Assured by Item_ref()
690
 
    if (rf->fix_fields(session, reference) || rf->check_cols(1))
691
 
      return -1;
692
 
 
693
 
    mark_as_dependent(session, last_checked_context->select_lex,
694
 
                      context->select_lex, this,
695
 
                      rf);
696
 
    return 0;
697
 
  }
698
 
  else
699
 
  {
700
 
    mark_as_dependent(session, last_checked_context->select_lex,
701
 
                      context->select_lex,
702
 
                      this, (Item_ident*)*reference);
703
 
    if (last_checked_context->select_lex->having_fix_field)
704
 
    {
705
 
      Item_ref *rf;
706
 
      rf= new Item_ref(context,
707
 
                       (cached_table->getSchemaName()[0] ? cached_table->getSchemaName() : 0),
708
 
                       (char*) cached_table->alias, (char*) field_name);
709
 
      if (!rf)
710
 
        return -1;
711
 
      session->change_item_tree(reference, rf);
712
 
      /*
713
 
        rf is Item_ref => never substitute other items (in this case)
714
 
        during fix_fields() => we can use rf after fix_fields()
715
 
      */
716
 
      assert(!rf->fixed);                // Assured by Item_ref()
717
 
      if (rf->fix_fields(session, reference) || rf->check_cols(1))
718
 
        return -1;
719
 
      return 0;
720
 
    }
721
 
  }
722
 
  return 1;
723
 
}
724
 
 
725
 
 
726
 
/**
727
 
  Resolve the name of a column reference.
728
 
 
729
 
  The method resolves the column reference represented by 'this' as a column
730
 
  present in one of: FROM clause, SELECT clause, GROUP BY clause of a query
731
 
  Q, or in outer queries that contain Q.
732
 
 
733
 
  The name resolution algorithm used is (where [T_j] is an optional table
734
 
  name that qualifies the column name):
735
 
 
736
 
  @code
737
 
    resolve_column_reference([T_j].col_ref_i)
738
 
    {
739
 
      search for a column or derived column named col_ref_i
740
 
      [in table T_j] in the FROM clause of Q;
741
 
 
742
 
      if such a column is NOT found AND    // Lookup in outer queries.
743
 
         there are outer queries
744
 
      {
745
 
        for each outer query Q_k beginning from the inner-most one
746
 
        {
747
 
          search for a column or derived column named col_ref_i
748
 
          [in table T_j] in the FROM clause of Q_k;
749
 
 
750
 
          if such a column is not found
751
 
            Search for a column or derived column named col_ref_i
752
 
            [in table T_j] in the SELECT and GROUP clauses of Q_k.
753
 
        }
754
 
      }
755
 
    }
756
 
  @endcode
757
 
 
758
 
    Notice that compared to Item_ref::fix_fields, here we first search the FROM
759
 
    clause, and then we search the SELECT and GROUP BY clauses.
760
 
 
761
 
  @param[in]     session        current thread
762
 
  @param[in,out] reference  view column if this item was resolved to a
763
 
    view column
764
 
 
765
 
  @retval
766
 
    true  if error
767
 
  @retval
768
 
    false on success
769
 
*/
770
 
 
771
 
bool Item_field::fix_fields(Session *session, Item **reference)
772
 
{
773
 
  assert(fixed == 0);
774
 
  Field *from_field= (Field *)not_found_field;
775
 
  bool outer_fixed= false;
776
 
 
777
 
  if (!field)                                   // If field is not checked
778
 
  {
779
 
    /*
780
 
      In case of view, find_field_in_tables() write pointer to view field
781
 
      expression to 'reference', i.e. it substitute that expression instead
782
 
      of this Item_field
783
 
    */
784
 
    if ((from_field= find_field_in_tables(session, this,
785
 
                                          context->first_name_resolution_table,
786
 
                                          context->last_name_resolution_table,
787
 
                                          reference,
788
 
                                          session->lex->use_only_table_context ?
789
 
                                            REPORT_ALL_ERRORS :
790
 
                                            IGNORE_EXCEPT_NON_UNIQUE, true)) ==
791
 
        not_found_field)
792
 
    {
793
 
      int ret;
794
 
      /* Look up in current select's item_list to find aliased fields */
795
 
      if (session->lex->current_select->is_item_list_lookup)
796
 
      {
797
 
        uint32_t counter;
798
 
        enum_resolution_type resolution;
799
 
        Item** res= find_item_in_list(session,
800
 
                                      this, session->lex->current_select->item_list,
801
 
                                      &counter, REPORT_EXCEPT_NOT_FOUND,
802
 
                                      &resolution);
803
 
        if (!res)
804
 
          return 1;
805
 
        if (resolution == RESOLVED_AGAINST_ALIAS)
806
 
          alias_name_used= true;
807
 
        if (res != (Item **)not_found_item)
808
 
        {
809
 
          if ((*res)->type() == Item::FIELD_ITEM)
810
 
          {
811
 
            /*
812
 
              It's an Item_field referencing another Item_field in the select
813
 
              list.
814
 
              Use the field from the Item_field in the select list and leave
815
 
              the Item_field instance in place.
816
 
            */
817
 
 
818
 
            Field *new_field= (*((Item_field**)res))->field;
819
 
 
820
 
            if (new_field == NULL)
821
 
            {
822
 
              /* The column to which we link isn't valid. */
823
 
              my_error(ER_BAD_FIELD_ERROR, MYF(0), (*res)->name,
824
 
                       current_session->where);
825
 
              return(1);
826
 
            }
827
 
 
828
 
            set_field(new_field);
829
 
            return 0;
830
 
          }
831
 
          else
832
 
          {
833
 
            /*
834
 
              It's not an Item_field in the select list so we must make a new
835
 
              Item_ref to point to the Item in the select list and replace the
836
 
              Item_field created by the parser with the new Item_ref.
837
 
            */
838
 
            Item_ref *rf= new Item_ref(context, db_name,table_name,field_name);
839
 
            if (!rf)
840
 
              return 1;
841
 
            session->change_item_tree(reference, rf);
842
 
            /*
843
 
              Because Item_ref never substitutes itself with other items
844
 
              in Item_ref::fix_fields(), we can safely use the original
845
 
              pointer to it even after fix_fields()
846
 
             */
847
 
            return rf->fix_fields(session, reference) ||  rf->check_cols(1);
848
 
          }
849
 
        }
850
 
      }
851
 
      if ((ret= fix_outer_field(session, &from_field, reference)) < 0)
852
 
        goto error;
853
 
      outer_fixed= true;
854
 
      if (!ret)
855
 
        goto mark_non_agg_field;
856
 
    }
857
 
    else if (!from_field)
858
 
      goto error;
859
 
 
860
 
    if (!outer_fixed && cached_table && cached_table->select_lex &&
861
 
        context->select_lex &&
862
 
        cached_table->select_lex != context->select_lex)
863
 
    {
864
 
      int ret;
865
 
      if ((ret= fix_outer_field(session, &from_field, reference)) < 0)
866
 
        goto error;
867
 
      outer_fixed= 1;
868
 
      if (!ret)
869
 
        goto mark_non_agg_field;
870
 
    }
871
 
 
872
 
    /*
873
 
      if it is not expression from merged VIEW we will set this field.
874
 
 
875
 
      We can leave expression substituted from view for next PS/SP rexecution
876
 
      (i.e. do not register this substitution for reverting on cleanup()
877
 
      (register_item_tree_changing())), because this subtree will be
878
 
      fix_field'ed during setup_tables()->setup_underlying() (i.e. before
879
 
      all other expressions of query, and references on tables which do
880
 
      not present in query will not make problems.
881
 
 
882
 
      Also we suppose that view can't be changed during PS/SP life.
883
 
    */
884
 
    if (from_field == view_ref_found)
885
 
      return false;
886
 
 
887
 
    set_field(from_field);
888
 
    if (session->lex->in_sum_func &&
889
 
        session->lex->in_sum_func->nest_level ==
890
 
        session->lex->current_select->nest_level)
891
 
    {
892
 
      set_if_bigger(session->lex->in_sum_func->max_arg_level,
893
 
                    session->lex->current_select->nest_level);
894
 
    }
895
 
  }
896
 
  else if (session->mark_used_columns != MARK_COLUMNS_NONE)
897
 
  {
898
 
    Table *table= field->getTable();
899
 
    boost::dynamic_bitset<> *current_bitmap, *other_bitmap;
900
 
    if (session->mark_used_columns == MARK_COLUMNS_READ)
901
 
    {
902
 
      current_bitmap= table->read_set;
903
 
      other_bitmap=   table->write_set;
904
 
    }
905
 
    else
906
 
    {
907
 
      current_bitmap= table->write_set;
908
 
      other_bitmap=   table->read_set;
909
 
    }
910
 
    //if (! current_bitmap->testAndSet(field->position()))
911
 
    if (! current_bitmap->test(field->position()))
912
 
    {
913
 
      if (! other_bitmap->test(field->position()))
914
 
      {
915
 
        /* First usage of column */
916
 
        table->used_fields++;                     // Used to optimize loops
917
 
        table->covering_keys&= field->part_of_key;
918
 
      }
919
 
    }
920
 
  }
921
 
  fixed= 1;
922
 
mark_non_agg_field:
923
 
  return false;
924
 
 
925
 
error:
926
 
  context->process_error(session);
927
 
  return true;
928
 
}
929
 
 
930
 
Item *Item_field::safe_charset_converter(const CHARSET_INFO * const tocs)
931
 
{
932
 
  no_const_subst= 1;
933
 
  return Item::safe_charset_converter(tocs);
934
 
}
935
 
 
936
 
 
937
 
void Item_field::cleanup()
938
 
{
939
 
  Item_ident::cleanup();
940
 
  /*
941
 
    Even if this object was created by direct link to field in setup_wild()
942
 
    it will be linked correctly next time by name of field and table alias.
943
 
    I.e. we can drop 'field'.
944
 
   */
945
 
  field= result_field= 0;
946
 
  null_value= false;
947
 
  return;
948
 
}
949
 
 
950
 
 
951
 
bool Item_field::result_as_int64_t()
952
 
{
953
 
  return field->can_be_compared_as_int64_t();
954
 
}
955
 
 
956
 
 
957
 
/**
958
 
  Find a field among specified multiple equalities.
959
 
 
960
 
  The function first searches the field among multiple equalities
961
 
  of the current level (in the cond_equal->current_level list).
962
 
  If it fails, it continues searching in upper levels accessed
963
 
  through a pointer cond_equal->upper_levels.
964
 
  The search terminates as soon as a multiple equality containing
965
 
  the field is found.
966
 
 
967
 
  @param cond_equal   reference to list of multiple equalities where
968
 
                      the field (this object) is to be looked for
969
 
 
970
 
  @return
971
 
    - First Item_equal containing the field, if success
972
 
    - 0, otherwise
973
 
*/
974
 
 
975
 
Item_equal *Item_field::find_item_equal(COND_EQUAL *cond_equal)
976
 
{
977
 
  Item_equal *item= 0;
978
 
  while (cond_equal)
979
 
  {
980
 
    List_iterator_fast<Item_equal> li(cond_equal->current_level);
981
 
    while ((item= li++))
982
 
    {
983
 
      if (item->contains(field))
984
 
        return item;
985
 
    }
986
 
    /*
987
 
      The field is not found in any of the multiple equalities
988
 
      of the current level. Look for it in upper levels
989
 
    */
990
 
    cond_equal= cond_equal->upper_levels;
991
 
  }
992
 
  return 0;
993
 
}
994
 
 
995
 
 
996
 
/**
997
 
  Check whether a field can be substituted by an equal item.
998
 
 
999
 
  The function checks whether a substitution of the field
1000
 
  occurrence for an equal item is valid.
1001
 
 
1002
 
  @param arg   *arg != NULL <-> the field is in the context where
1003
 
               substitution for an equal item is valid
1004
 
 
1005
 
  @note
1006
 
    The following statement is not always true:
1007
 
  @n
1008
 
    x=y => F(x)=F(x/y).
1009
 
  @n
1010
 
    This means substitution of an item for an equal item not always
1011
 
    yields an equavalent condition. Here's an example:
1012
 
    @code
1013
 
    'a'='a '
1014
 
    (LENGTH('a')=1) != (LENGTH('a ')=2)
1015
 
  @endcode
1016
 
    Such a substitution is surely valid if either the substituted
1017
 
    field is not of a STRING type or if it is an argument of
1018
 
    a comparison predicate.
1019
 
 
1020
 
  @retval
1021
 
    true   substitution is valid
1022
 
  @retval
1023
 
    false  otherwise
1024
 
*/
1025
 
 
1026
 
bool Item_field::subst_argument_checker(unsigned char **arg)
1027
 
{
1028
 
  return (result_type() != STRING_RESULT) || (*arg);
1029
 
}
1030
 
 
1031
 
 
1032
 
/**
1033
 
  Set a pointer to the multiple equality the field reference belongs to
1034
 
  (if any).
1035
 
 
1036
 
  The function looks for a multiple equality containing the field item
1037
 
  among those referenced by arg.
1038
 
  In the case such equality exists the function does the following.
1039
 
  If the found multiple equality contains a constant, then the field
1040
 
  reference is substituted for this constant, otherwise it sets a pointer
1041
 
  to the multiple equality in the field item.
1042
 
 
1043
 
 
1044
 
  @param arg    reference to list of multiple equalities where
1045
 
                the field (this object) is to be looked for
1046
 
 
1047
 
  @note
1048
 
    This function is supposed to be called as a callback parameter in calls
1049
 
    of the compile method.
1050
 
 
1051
 
  @return
1052
 
    - pointer to the replacing constant item, if the field item was substituted
1053
 
    - pointer to the field item, otherwise.
1054
 
*/
1055
 
 
1056
 
Item *Item_field::equal_fields_propagator(unsigned char *arg)
1057
 
{
1058
 
  if (no_const_subst)
1059
 
    return this;
1060
 
  item_equal= find_item_equal((COND_EQUAL *) arg);
1061
 
  Item *item= 0;
1062
 
  if (item_equal)
1063
 
    item= item_equal->get_const();
1064
 
  /*
1065
 
    Disable const propagation for items used in different comparison contexts.
1066
 
    This must be done because, for example, Item_hex_string->val_int() is not
1067
 
    the same as (Item_hex_string->val_str() in BINARY column)->val_int().
1068
 
    We cannot simply disable the replacement in a particular context (
1069
 
    e.g. <bin_col> = <int_col> AND <bin_col> = <hex_string>) since
1070
 
    Items don't know the context they are in and there are functions like
1071
 
    IF (<hex_string>, 'yes', 'no').
1072
 
    The same problem occurs when comparing a DATE/TIME field with a
1073
 
    DATE/TIME represented as an int and as a string.
1074
 
  */
1075
 
  if (!item ||
1076
 
      (cmp_context != (Item_result)-1 && item->cmp_context != cmp_context))
1077
 
    item= this;
1078
 
 
1079
 
  return item;
1080
 
}
1081
 
 
1082
 
 
1083
 
/**
1084
 
  Mark the item to not be part of substitution if it's not a binary item.
1085
 
 
1086
 
  See comments in Arg_comparator::set_compare_func() for details.
1087
 
*/
1088
 
 
1089
 
bool Item_field::set_no_const_sub(unsigned char *)
1090
 
{
1091
 
  if (field->charset() != &my_charset_bin)
1092
 
    no_const_subst=1;
1093
 
  return false;
1094
 
}
1095
 
 
1096
 
 
1097
 
/**
1098
 
  Replace an Item_field for an equal Item_field that evaluated earlier
1099
 
  (if any).
1100
 
 
1101
 
  The function returns a pointer to an item that is taken from
1102
 
  the very beginning of the item_equal list which the Item_field
1103
 
  object refers to (belongs to) unless item_equal contains  a constant
1104
 
  item. In this case the function returns this constant item,
1105
 
  (if the substitution does not require conversion).
1106
 
  If the Item_field object does not refer any Item_equal object
1107
 
  'this' is returned .
1108
 
 
1109
 
  @param arg   a dummy parameter, is not used here
1110
 
 
1111
 
 
1112
 
  @note
1113
 
    This function is supposed to be called as a callback parameter in calls
1114
 
    of the thransformer method.
1115
 
 
1116
 
  @return
1117
 
    - pointer to a replacement Item_field if there is a better equal item or
1118
 
      a pointer to a constant equal item;
1119
 
    - this - otherwise.
1120
 
*/
1121
 
 
1122
 
Item *Item_field::replace_equal_field(unsigned char *)
1123
 
{
1124
 
  if (item_equal)
1125
 
  {
1126
 
    Item *const_item_ptr= item_equal->get_const();
1127
 
    if (const_item_ptr)
1128
 
    {
1129
 
      if (cmp_context != (Item_result)-1 &&
1130
 
          const_item_ptr->cmp_context != cmp_context)
1131
 
        return this;
1132
 
      return const_item_ptr;
1133
 
    }
1134
 
    Item_field *subst= item_equal->get_first();
1135
 
    if (subst && !field->eq(subst->field))
1136
 
      return subst;
1137
 
  }
1138
 
  return this;
1139
 
}
1140
 
 
1141
 
 
1142
 
uint32_t Item_field::max_disp_length()
1143
 
{
1144
 
  return field->max_display_length();
1145
 
}
1146
 
 
1147
 
 
1148
 
/* ARGSUSED */
1149
 
void Item_field::make_field(SendField *tmp_field)
1150
 
{
1151
 
  field->make_field(tmp_field);
1152
 
  assert(tmp_field->table_name != 0);
1153
 
  if (name)
1154
 
    tmp_field->col_name=name;                   // Use user supplied name
1155
 
  if (table_name)
1156
 
    tmp_field->table_name= table_name;
1157
 
  if (db_name)
1158
 
    tmp_field->db_name= db_name;
1159
 
}
1160
 
 
1161
 
 
1162
 
/**
1163
 
  Set a field's value from a item.
1164
 
*/
1165
 
 
1166
 
void Item_field::save_org_in_field(Field *to)
1167
 
{
1168
 
  if (field->is_null())
1169
 
  {
1170
 
    null_value=1;
1171
 
    set_field_to_null_with_conversions(to, 1);
1172
 
  }
1173
 
  else
1174
 
  {
1175
 
    to->set_notnull();
1176
 
    field_conv(to,field);
1177
 
    null_value=0;
1178
 
  }
1179
 
}
1180
 
 
1181
 
int Item_field::save_in_field(Field *to, bool no_conversions)
1182
 
{
1183
 
  int res;
1184
 
  if (result_field->is_null())
1185
 
  {
1186
 
    null_value=1;
1187
 
    res= set_field_to_null_with_conversions(to, no_conversions);
1188
 
  }
1189
 
  else
1190
 
  {
1191
 
    to->set_notnull();
1192
 
    res= field_conv(to,result_field);
1193
 
    null_value=0;
1194
 
  }
1195
 
  return(res);
1196
 
}
1197
 
 
1198
 
 
1199
 
bool Item_field::send(plugin::Client *client, String *)
1200
 
{
1201
 
  return client->store(result_field);
1202
 
}
1203
 
 
1204
 
 
1205
 
void Item_field::update_null_value()
1206
 
{
1207
 
  /*
1208
 
    need to set no_errors to prevent warnings about type conversion
1209
 
    popping up.
1210
 
  */
1211
 
  Session *session= field->getTable()->in_use;
1212
 
  int no_errors;
1213
 
 
1214
 
  no_errors= session->no_errors;
1215
 
  session->no_errors= 1;
1216
 
  Item::update_null_value();
1217
 
  session->no_errors= no_errors;
1218
 
}
1219
 
 
1220
 
 
1221
 
/*
1222
 
  Add the field to the select list and substitute it for the reference to
1223
 
  the field.
1224
 
 
1225
 
  SYNOPSIS
1226
 
    Item_field::update_value_transformer()
1227
 
    select_arg      current select
1228
 
 
1229
 
  DESCRIPTION
1230
 
    If the field doesn't belong to the table being inserted into then it is
1231
 
    added to the select list, pointer to it is stored in the ref_pointer_array
1232
 
    of the select and the field itself is substituted for the Item_ref object.
1233
 
    This is done in order to get correct values from update fields that
1234
 
    belongs to the SELECT part in the INSERT .. SELECT .. ON DUPLICATE KEY
1235
 
    UPDATE statement.
1236
 
 
1237
 
  RETURN
1238
 
    0             if error occured
1239
 
    ref           if all conditions are met
1240
 
    this field    otherwise
1241
 
*/
1242
 
 
1243
 
Item *Item_field::update_value_transformer(unsigned char *select_arg)
1244
 
{
1245
 
  Select_Lex *select= (Select_Lex*)select_arg;
1246
 
  assert(fixed);
1247
 
 
1248
 
  if (field->getTable() != select->context.table_list->table)
1249
 
  {
1250
 
    List<Item> *all_fields= &select->join->all_fields;
1251
 
    Item **ref_pointer_array= select->ref_pointer_array;
1252
 
    int el= all_fields->elements;
1253
 
    Item_ref *ref;
1254
 
 
1255
 
    ref_pointer_array[el]= (Item*)this;
1256
 
    all_fields->push_front((Item*)this);
1257
 
    ref= new Item_ref(&select->context, ref_pointer_array + el,
1258
 
                      table_name, field_name);
1259
 
    return ref;
1260
 
  }
1261
 
  return this;
1262
 
}
1263
 
 
1264
 
 
1265
 
void Item_field::print(String *str, enum_query_type query_type)
1266
 
{
1267
 
  if (field && field->getTable()->const_table)
1268
 
  {
1269
 
    char buff[MAX_FIELD_WIDTH];
1270
 
    String tmp(buff,sizeof(buff),str->charset());
1271
 
    field->val_str_internal(&tmp);
1272
 
    if (field->is_null())  {
1273
 
      str->append("NULL");
1274
 
    }
1275
 
    else {
1276
 
      str->append('\'');
1277
 
      str->append(tmp);
1278
 
      str->append('\'');
1279
 
    }
1280
 
    return;
1281
 
  }
1282
 
  Item_ident::print(str, query_type);
1283
 
}
1284
 
 
1285
 
 
1286
 
} /* namespace drizzled */