← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item_subselect.cc

  • Committer: Monty Taylor
  • Date: 2008-08-22 04:35:12 UTC
  • mto: (365.1.2 drizzle)
  • mto: This revision was merged to the branch mainline in revision 368.
  • Revision ID: monty@inaugust.com-20080822043512-3vafw99x3vv97d39
INT32_MAX stuff.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item_subselect.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/**
17
17
  @file
20
20
  subselect Item
21
21
 
22
22
  @todo
23
 
    - add function from select_query that use JOIN* as parameter to JOIN
 
23
    - add function from mysql_select that use JOIN* as parameter to JOIN
24
24
    methods (sql_select.h/sql_select.cc)
25
25
*/
26
 
#include "config.h"
27
 
 
28
 
#include <cstdio>
29
 
#include <limits.h>
30
 
 
 
26
#include <drizzled/server_includes.h>
31
27
#include <drizzled/sql_select.h>
32
 
#include <drizzled/error.h>
33
 
#include <drizzled/item/cache.h>
34
 
#include <drizzled/item/subselect.h>
35
 
#include <drizzled/item/cmpfunc.h>
36
 
#include <drizzled/item/ref_null_helper.h>
37
 
#include <drizzled/cached_item.h>
38
 
#include <drizzled/check_stack_overrun.h>
39
 
#include <drizzled/item/ref_null_helper.h>
40
 
#include <drizzled/item/direct_ref.h>
41
 
#include <drizzled/join.h>
42
 
#include <drizzled/plugin/storage_engine.h>
43
 
 
44
 
namespace drizzled
45
 
{
46
 
 
47
 
extern plugin::StorageEngine *myisam_engine;
 
28
#include <drizzled/drizzled_error_messages.h>
48
29
 
49
30
inline Item * and_items(Item* cond, Item *item)
50
31
{
51
32
  return (cond? (new Item_cond_and(cond, item)) : item);
52
33
}
53
34
 
54
 
Item_subselect::Item_subselect() :
55
 
  Item_result_field(),
56
 
  value_assigned(false),
57
 
  session(NULL),
58
 
  substitution(NULL),
59
 
  unit(NULL),
60
 
  engine(NULL),
61
 
  old_engine(NULL),
62
 
  used_tables_cache(0),
63
 
  max_columns(0),
64
 
  parsing_place(NO_MATTER),
65
 
  have_to_be_excluded(false),
66
 
  const_item_cache(true),
67
 
  engine_changed(false),
68
 
  changed(false),
 
35
Item_subselect::Item_subselect():
 
36
  Item_result_field(), value_assigned(0), thd(0), substitution(0),
 
37
  engine(0), old_engine(0), used_tables_cache(0), have_to_be_excluded(0),
 
38
  const_item_cache(1), engine_changed(0), changed(0),
69
39
  is_correlated(false)
70
40
{
71
41
  with_subselect= 1;
78
48
}
79
49
 
80
50
 
81
 
void Item_subselect::init(Select_Lex *select_lex,
 
51
void Item_subselect::init(st_select_lex *select_lex,
82
52
                          select_result_interceptor *result)
83
53
{
84
54
  /*
91
61
  if (unit->item)
92
62
  {
93
63
    /*
94
 
      Item can be changed in JOIN::prepare while engine in Join::optimize
 
64
      Item can be changed in JOIN::prepare while engine in JOIN::optimize
95
65
      => we do not copy old_engine here
96
66
    */
97
67
    engine= unit->item->engine;
102
72
  }
103
73
  else
104
74
  {
105
 
    Select_Lex *outer_select= unit->outer_select();
 
75
    SELECT_LEX *outer_select= unit->outer_select();
106
76
    /*
107
77
      do not take into account expression inside aggregate functions because
108
78
      they can access original table fields
116
86
      engine= new subselect_single_select_engine(select_lex, result, this);
117
87
  }
118
88
  {
119
 
    Select_Lex *upper= unit->outer_select();
 
89
    SELECT_LEX *upper= unit->outer_select();
120
90
    if (upper->parsing_place == IN_HAVING)
121
91
      upper->subquery_in_having= 1;
122
92
  }
123
93
  return;
124
94
}
125
95
 
126
 
Select_Lex *
 
96
st_select_lex *
127
97
Item_subselect::get_select_lex()
128
98
{
129
99
  return unit->first_select();
173
143
}
174
144
 
175
145
Item_subselect::trans_res
176
 
Item_subselect::select_transformer(Join *)
 
146
Item_subselect::select_transformer(JOIN *join __attribute__((unused)))
177
147
{
178
148
  return(RES_OK);
179
149
}
180
150
 
181
151
 
182
 
bool Item_subselect::fix_fields(Session *session_param, Item **ref)
 
152
bool Item_subselect::fix_fields(THD *thd_param, Item **ref)
183
153
{
184
 
  char const *save_where= session_param->where();
 
154
  char const *save_where= thd_param->where;
 
155
  uint8_t uncacheable;
185
156
  bool res;
186
157
 
187
158
  assert(fixed == 0);
188
 
  engine->set_session((session= session_param));
 
159
  engine->set_thd((thd= thd_param));
189
160
 
190
 
  if (check_stack_overrun(session, STACK_MIN_SIZE, (unsigned char*)&res))
 
161
  if (check_stack_overrun(thd, STACK_MIN_SIZE, (uchar*)&res))
191
162
    return true;
192
163
 
193
164
  res= engine->prepare();
209
180
 
210
181
      // did we changed top item of WHERE condition
211
182
      if (unit->outer_select()->where == (*ref))
212
 
      {
213
 
        unit->outer_select()->where= substitution; // correct WHERE for PS
214
 
      }
 
183
        unit->outer_select()->where= substitution; // correct WHERE for PS
215
184
      else if (unit->outer_select()->having == (*ref))
216
 
      {
217
 
        unit->outer_select()->having= substitution; // correct HAVING for PS
218
 
      }
 
185
        unit->outer_select()->having= substitution; // correct HAVING for PS
219
186
 
220
187
      (*ref)= substitution;
221
188
      substitution->name= name;
222
189
      if (have_to_be_excluded)
223
 
      {
224
 
        engine->exclude();
225
 
      }
 
190
        engine->exclude();
226
191
      substitution= 0;
227
 
      session->setWhere("checking transformed subquery");
228
 
      if (! (*ref)->fixed)
229
 
      {
230
 
        ret= (*ref)->fix_fields(session, ref);
231
 
      }
232
 
      session->setWhere(save_where);
233
 
 
 
192
      thd->where= "checking transformed subquery";
 
193
      if (!(*ref)->fixed)
 
194
        ret= (*ref)->fix_fields(thd, ref);
 
195
      thd->where= save_where;
234
196
      return ret;
235
197
    }
236
198
    // Is it one field subselect?
243
205
  }
244
206
  else
245
207
    goto err;
246
 
 
247
 
  if (engine->uncacheable())
 
208
  
 
209
  if ((uncacheable= engine->uncacheable()))
248
210
  {
249
 
    const_item_cache= false;
250
 
    if (engine->uncacheable(UNCACHEABLE_RAND))
251
 
    {
 
211
    const_item_cache= 0;
 
212
    if (uncacheable & UNCACHEABLE_RAND)
252
213
      used_tables_cache|= RAND_TABLE_BIT;
253
 
    }
254
214
  }
255
215
  fixed= 1;
256
216
 
257
217
err:
258
 
  session->setWhere(save_where);
 
218
  thd->where= save_where;
259
219
  return res;
260
220
}
261
221
 
262
222
 
263
223
bool Item_subselect::walk(Item_processor processor, bool walk_subquery,
264
 
                          unsigned char *argument)
 
224
                          uchar *argument)
265
225
{
266
226
 
267
227
  if (walk_subquery)
268
228
  {
269
 
    for (Select_Lex *lex= unit->first_select(); lex; lex= lex->next_select())
 
229
    for (SELECT_LEX *lex= unit->first_select(); lex; lex= lex->next_select())
270
230
    {
271
231
      List_iterator<Item> li(lex->item_list);
272
232
      Item *item;
273
 
      Order *order;
 
233
      order_st *order;
274
234
 
275
235
      if (lex->where && (lex->where)->walk(processor, walk_subquery, argument))
276
236
        return 1;
283
243
        if (item->walk(processor, walk_subquery, argument))
284
244
          return 1;
285
245
      }
286
 
      for (order= (Order*) lex->order_list.first ; order; order= order->next)
 
246
      for (order= (order_st*) lex->order_list.first ; order; order= order->next)
287
247
      {
288
248
        if ((*order->item)->walk(processor, walk_subquery, argument))
289
249
          return 1;
290
250
      }
291
 
      for (order= (Order*) lex->group_list.first ; order; order= order->next)
 
251
      for (order= (order_st*) lex->group_list.first ; order; order= order->next)
292
252
      {
293
253
        if ((*order->item)->walk(processor, walk_subquery, argument))
294
254
          return 1;
303
263
{
304
264
  int res;
305
265
 
306
 
  if (session->is_error())
 
266
  if (thd->is_error())
307
267
  /* Do not execute subselect in case of a fatal error */
308
268
    return 1;
309
269
 
383
343
  return const_item_cache;
384
344
}
385
345
 
386
 
Item *Item_subselect::get_tmp_table_item(Session *session_arg)
 
346
Item *Item_subselect::get_tmp_table_item(THD *thd_arg)
387
347
{
388
348
  if (!with_sum_func && !const_item())
389
349
    return new Item_field(result_field);
390
 
  return copy_or_same(session_arg);
 
350
  return copy_or_same(thd_arg);
391
351
}
392
352
 
393
353
void Item_subselect::update_used_tables()
394
354
{
395
 
  if (! engine->uncacheable())
 
355
  if (!engine->uncacheable())
396
356
  {
397
357
    // did all used tables become static?
398
358
    if (!(used_tables_cache & ~engine->upper_select_const_tables()))
399
 
      const_item_cache= true;
 
359
      const_item_cache= 1;
400
360
  }
401
361
}
402
362
 
409
369
}
410
370
 
411
371
 
412
 
Item_singlerow_subselect::Item_singlerow_subselect(Select_Lex *select_lex)
 
372
Item_singlerow_subselect::Item_singlerow_subselect(st_select_lex *select_lex)
413
373
  :Item_subselect(), value(0)
414
374
{
415
375
  init(select_lex, new select_singlerow_subselect(this));
418
378
  return;
419
379
}
420
380
 
421
 
Select_Lex *
 
381
st_select_lex *
422
382
Item_singlerow_subselect::invalidate_and_restore_select_lex()
423
383
{
424
 
  Select_Lex *result= get_select_lex();
 
384
  st_select_lex *result= get_select_lex();
425
385
 
426
386
  assert(result);
427
387
 
428
388
  /*
429
389
    This code restore the parse tree in it's state before the execution of
430
390
    Item_singlerow_subselect::Item_singlerow_subselect(),
431
 
    and in particular decouples this object from the Select_Lex,
432
 
    so that the Select_Lex can be used with a different flavor
 
391
    and in particular decouples this object from the SELECT_LEX,
 
392
    so that the SELECT_LEX can be used with a different flavor
433
393
    or Item_subselect instead, as part of query rewriting.
434
394
  */
435
395
  unit->item= NULL;
437
397
  return(result);
438
398
}
439
399
 
440
 
Item_maxmin_subselect::Item_maxmin_subselect(Session *session_param,
 
400
Item_maxmin_subselect::Item_maxmin_subselect(THD *thd_param,
441
401
                                             Item_subselect *parent,
442
 
                                             Select_Lex *select_lex,
 
402
                                             st_select_lex *select_lex,
443
403
                                             bool max_arg)
444
404
  :Item_singlerow_subselect(), was_values(true)
445
405
{
458
418
 
459
419
  /*
460
420
    this subquery always creates during preparation, so we can assign
461
 
    session here
 
421
    thd here
462
422
  */
463
 
  session= session_param;
 
423
  thd= thd_param;
464
424
 
465
425
  return;
466
426
}
508
468
  Make rollback for it, or special name resolving mode in 5.0.
509
469
*/
510
470
Item_subselect::trans_res
511
 
Item_singlerow_subselect::select_transformer(Join *join)
 
471
Item_singlerow_subselect::select_transformer(JOIN *join)
512
472
{
513
473
  if (changed)
514
474
    return(RES_OK);
515
475
 
516
 
  Select_Lex *select_lex= join->select_lex;
517
 
 
 
476
  SELECT_LEX *select_lex= join->select_lex;
 
477
 
518
478
  if (!select_lex->master_unit()->is_union() &&
519
479
      !select_lex->table_list.elements &&
520
480
      select_lex->item_list.elements == 1 &&
533
493
  {
534
494
 
535
495
    have_to_be_excluded= 1;
536
 
    if (session->lex->describe)
 
496
    if (thd->lex->describe)
537
497
    {
538
498
      char warn_buff[DRIZZLE_ERRMSG_SIZE];
539
 
      snprintf(warn_buff, sizeof(warn_buff), ER(ER_SELECT_REDUCED), select_lex->select_number);
540
 
      push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
499
      sprintf(warn_buff, ER(ER_SELECT_REDUCED), select_lex->select_number);
 
500
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
541
501
                   ER_SELECT_REDUCED, warn_buff);
542
502
    }
543
503
    substitution= select_lex->item_list.head();
546
506
      'upper' select is not really dependent => we remove this dependence
547
507
    */
548
508
    substitution->walk(&Item::remove_dependence_processor, 0,
549
 
                       (unsigned char *) select_lex->outer_select());
 
509
                       (uchar *) select_lex->outer_select());
550
510
    return(RES_REDUCE);
551
511
  }
552
512
  return(RES_OK);
553
513
}
554
514
 
555
515
 
556
 
void Item_singlerow_subselect::store(uint32_t i, Item *item)
 
516
void Item_singlerow_subselect::store(uint i, Item *item)
557
517
{
558
518
  row[i]->store(item);
559
519
}
563
523
  return engine->type();
564
524
}
565
525
 
566
 
/*
567
 
 Don't rely on the result type to calculate field type.
 
526
/* 
 
527
 Don't rely on the result type to calculate field type. 
568
528
 Ask the engine instead.
569
529
*/
570
530
enum_field_types Item_singlerow_subselect::field_type() const
580
540
  }
581
541
  else
582
542
  {
583
 
    if (!(row= (Item_cache**) memory::sql_alloc(sizeof(Item_cache*)*max_columns)))
 
543
    if (!(row= (Item_cache**) sql_alloc(sizeof(Item_cache*)*max_columns)))
584
544
      return;
585
545
    engine->fix_length_and_dec(row);
586
546
    value= *row;
595
555
    maybe_null= engine->may_be_null();
596
556
}
597
557
 
598
 
uint32_t Item_singlerow_subselect::cols()
 
558
uint Item_singlerow_subselect::cols()
599
559
{
600
560
  return engine->cols();
601
561
}
602
562
 
603
 
bool Item_singlerow_subselect::check_cols(uint32_t c)
 
563
bool Item_singlerow_subselect::check_cols(uint c)
604
564
{
605
565
  if (c != engine->cols())
606
566
  {
612
572
 
613
573
bool Item_singlerow_subselect::null_inside()
614
574
{
615
 
  for (uint32_t i= 0; i < max_columns ; i++)
 
575
  for (uint i= 0; i < max_columns ; i++)
616
576
  {
617
577
    if (row[i]->null_value)
618
578
      return 1;
670
630
}
671
631
 
672
632
 
673
 
type::Decimal *Item_singlerow_subselect::val_decimal(type::Decimal *decimal_value)
 
633
my_decimal *Item_singlerow_subselect::val_decimal(my_decimal *decimal_value)
674
634
{
675
635
  if (!exec() && !value->null_value)
676
636
  {
700
660
}
701
661
 
702
662
 
703
 
Item_exists_subselect::Item_exists_subselect(Select_Lex *select_lex):
 
663
Item_exists_subselect::Item_exists_subselect(st_select_lex *select_lex):
704
664
  Item_subselect()
705
665
{
706
666
  bool val_bool();
720
680
}
721
681
 
722
682
 
723
 
bool Item_in_subselect::test_limit(Select_Lex_Unit *unit_arg)
 
683
bool Item_in_subselect::test_limit(st_select_lex_unit *unit_arg)
724
684
{
725
685
  if (unit_arg->fake_select_lex &&
726
686
      unit_arg->fake_select_lex->test_limit())
727
687
    return(1);
728
688
 
729
 
  Select_Lex *sl= unit_arg->first_select();
 
689
  SELECT_LEX *sl= unit_arg->first_select();
730
690
  for (; sl; sl= sl->next_select())
731
691
  {
732
692
    if (sl->test_limit())
736
696
}
737
697
 
738
698
Item_in_subselect::Item_in_subselect(Item * left_exp,
739
 
                                     Select_Lex *select_lex) :
740
 
  Item_exists_subselect(),
741
 
  left_expr(left_exp),
742
 
  left_expr_cache(NULL),
743
 
  first_execution(true),
744
 
  optimizer(NULL),
745
 
  pushed_cond_guards(NULL),
746
 
  sj_convert_priority(0),
747
 
  expr_join_nest(NULL),
748
 
  exec_method(NOT_TRANSFORMED),
749
 
  upper_item(NULL)
 
699
                                     st_select_lex *select_lex):
 
700
  Item_exists_subselect(), left_expr_cache(0), first_execution(true),
 
701
  optimizer(0), pushed_cond_guards(NULL), exec_method(NOT_TRANSFORMED),
 
702
  upper_item(0)
750
703
{
 
704
  left_expr= left_exp;
751
705
  init(select_lex, new select_exists_subselect(this));
752
706
  max_columns= UINT_MAX;
753
707
  maybe_null= 1;
760
714
 
761
715
Item_allany_subselect::Item_allany_subselect(Item * left_exp,
762
716
                                             chooser_compare_func_creator fc,
763
 
                                             Select_Lex *select_lex,
 
717
                                             st_select_lex *select_lex,
764
718
                                             bool all_arg)
765
719
  :Item_in_subselect(), func_creator(fc), all(all_arg)
766
720
{
820
774
}
821
775
 
822
776
 
823
 
type::Decimal *Item_exists_subselect::val_decimal(type::Decimal *decimal_value)
 
777
my_decimal *Item_exists_subselect::val_decimal(my_decimal *decimal_value)
824
778
{
825
779
  assert(fixed == 1);
826
780
  if (exec())
828
782
    reset();
829
783
    return 0;
830
784
  }
831
 
  int2_class_decimal(E_DEC_FATAL_ERROR, value, 0, decimal_value);
 
785
  int2my_decimal(E_DEC_FATAL_ERROR, value, 0, decimal_value);
832
786
  return decimal_value;
833
787
}
834
788
 
918
872
  if (exec())
919
873
  {
920
874
    reset();
921
 
    /*
 
875
    /* 
922
876
      Must mark the IN predicate as NULL so as to make sure an enclosing NOT
923
 
      predicate will return false. See the comments in
 
877
      predicate will return false. See the comments in 
924
878
      subselect_uniquesubquery_engine::copy_ref_key for further details.
925
879
    */
926
880
    null_value= 1;
931
885
  return value;
932
886
}
933
887
 
934
 
type::Decimal *Item_in_subselect::val_decimal(type::Decimal *decimal_value)
 
888
my_decimal *Item_in_subselect::val_decimal(my_decimal *decimal_value)
935
889
{
936
890
  /*
937
891
    As far as Item_in_subselect called only from Item_in_optimizer this
948
902
  }
949
903
  if (was_null && !value)
950
904
    null_value= 1;
951
 
  int2_class_decimal(E_DEC_FATAL_ERROR, value, 0, decimal_value);
 
905
  int2my_decimal(E_DEC_FATAL_ERROR, value, 0, decimal_value);
952
906
  return decimal_value;
953
907
}
954
908
 
955
909
 
956
 
/*
 
910
/* 
957
911
  Rewrite a single-column IN/ALL/ANY subselect
958
912
 
959
913
  SYNOPSIS
963
917
 
964
918
  DESCRIPTION
965
919
    Rewrite a single-column subquery using rule-based approach. The subquery
966
 
 
 
920
    
967
921
       oe $cmp$ (SELECT ie FROM ... WHERE subq_where ... HAVING subq_having)
968
 
 
 
922
    
969
923
    First, try to convert the subquery to scalar-result subquery in one of
970
924
    the forms:
971
 
 
 
925
    
972
926
       - oe $cmp$ (SELECT MAX(...) )  // handled by Item_singlerow_subselect
973
927
       - oe $cmp$ <max>(SELECT ...)   // handled by Item_maxmin_subselect
974
 
 
 
928
   
975
929
    If that fails, the subquery will be handled with class Item_in_optimizer.
976
930
    There are two possibilites:
977
931
    - If the subquery execution method is materialization, then the subquery is
988
942
*/
989
943
 
990
944
Item_subselect::trans_res
991
 
Item_in_subselect::single_value_transformer(Join *join,
992
 
                                            const Comp_creator *func)
 
945
Item_in_subselect::single_value_transformer(JOIN *join,
 
946
                                            Comp_creator *func)
993
947
{
994
 
  Select_Lex *select_lex= join->select_lex;
 
948
  SELECT_LEX *select_lex= join->select_lex;
995
949
 
996
950
  /*
997
951
    Check that the right part of the subselect contains no more than one
1015
969
    later in this method.
1016
970
  */
1017
971
  if ((abort_on_null || (upper_item && upper_item->top_level())) &&
1018
 
      select_lex->master_unit()->uncacheable.none() && !func->eqne_op())
 
972
      !select_lex->master_unit()->uncacheable && !func->eqne_op())
1019
973
  {
1020
974
    if (substitution)
1021
975
    {
1057
1011
        it.replace(item);
1058
1012
      }
1059
1013
 
1060
 
      save_allow_sum_func= session->lex->allow_sum_func;
1061
 
      session->lex->allow_sum_func|= 1 << session->lex->current_select->nest_level;
 
1014
      save_allow_sum_func= thd->lex->allow_sum_func;
 
1015
      thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
1062
1016
      /*
1063
1017
        Item_sum_(max|min) can't substitute other item => we can use 0 as
1064
1018
        reference, also Item_sum_(max|min) can't be fixed after creation, so
1065
1019
        we do not check item->fixed
1066
1020
      */
1067
 
      if (item->fix_fields(session, 0))
 
1021
      if (item->fix_fields(thd, 0))
1068
1022
        return(RES_ERROR);
1069
 
      session->lex->allow_sum_func= save_allow_sum_func;
 
1023
      thd->lex->allow_sum_func= save_allow_sum_func; 
1070
1024
      /* we added aggregate function => we have to change statistic */
1071
 
      count_field_types(select_lex, &join->tmp_table_param, join->all_fields,
 
1025
      count_field_types(select_lex, &join->tmp_table_param, join->all_fields, 
1072
1026
                        0);
1073
1027
 
1074
1028
      subs= new Item_singlerow_subselect(select_lex);
1076
1030
    else
1077
1031
    {
1078
1032
      Item_maxmin_subselect *item;
1079
 
      subs= item= new Item_maxmin_subselect(session, this, select_lex, func->l_op());
 
1033
      subs= item= new Item_maxmin_subselect(thd, this, select_lex, func->l_op());
1080
1034
      if (upper_item)
1081
1035
        upper_item->set_sub_test(item);
1082
1036
    }
1088
1042
  if (!substitution)
1089
1043
  {
1090
1044
    /* We're invoked for the 1st (or the only) SELECT in the subquery UNION */
1091
 
    Select_Lex_Unit *master_unit= select_lex->master_unit();
 
1045
    SELECT_LEX_UNIT *master_unit= select_lex->master_unit();
1092
1046
    substitution= optimizer;
1093
1047
 
1094
 
    Select_Lex *current= session->lex->current_select, *up;
 
1048
    SELECT_LEX *current= thd->lex->current_select, *up;
1095
1049
 
1096
 
    session->lex->current_select= up= current->return_after_parsing();
 
1050
    thd->lex->current_select= up= current->return_after_parsing();
1097
1051
    //optimizer never use Item **ref => we can pass 0 as parameter
1098
 
    if (!optimizer || optimizer->fix_left(session, 0))
 
1052
    if (!optimizer || optimizer->fix_left(thd, 0))
1099
1053
    {
1100
 
      session->lex->current_select= current;
 
1054
      thd->lex->current_select= current;
1101
1055
      return(RES_ERROR);
1102
1056
    }
1103
 
    session->lex->current_select= current;
 
1057
    thd->lex->current_select= current;
1104
1058
 
1105
1059
    /*
1106
1060
      As far as  Item_ref_in_optimizer do not substitute itself on fix_fields
1111
1065
                              (char *)"<no matter>",
1112
1066
                              (char *)in_left_expr_name);
1113
1067
 
1114
 
    master_unit->uncacheable.set(UNCACHEABLE_DEPENDENT);
 
1068
    master_unit->uncacheable|= UNCACHEABLE_DEPENDENT;
1115
1069
  }
1116
1070
 
1117
1071
  if (!abort_on_null && left_expr->maybe_null && !pushed_cond_guards)
1118
1072
  {
1119
 
    if (!(pushed_cond_guards= (bool*)join->session->getMemRoot()->allocate(sizeof(bool))))
 
1073
    if (!(pushed_cond_guards= (bool*)join->thd->alloc(sizeof(bool))))
1120
1074
      return(RES_ERROR);
1121
1075
    pushed_cond_guards[0]= true;
1122
1076
  }
1141
1095
 
1142
1096
  - If the subquery has aggregates, GROUP BY, or HAVING, convert to
1143
1097
 
1144
 
    SELECT ie FROM ...  HAVING subq_having AND
 
1098
    SELECT ie FROM ...  HAVING subq_having AND 
1145
1099
                               trigcond(oe $cmp$ ref_or_null_helper<ie>)
1146
 
 
 
1100
                                   
1147
1101
    the addition is wrapped into trigger only when we want to distinguish
1148
1102
    between NULL and false results.
1149
1103
 
1151
1105
    following:
1152
1106
 
1153
1107
    = If we don't need to distinguish between NULL and false subquery:
1154
 
 
 
1108
        
1155
1109
      SELECT 1 FROM ... WHERE (oe $cmp$ ie) AND subq_where
1156
1110
 
1157
1111
    = If we need to distinguish between those:
1170
1124
*/
1171
1125
 
1172
1126
Item_subselect::trans_res
1173
 
Item_in_subselect::single_value_in_to_exists_transformer(Join * join, const Comp_creator *func)
 
1127
Item_in_subselect::single_value_in_to_exists_transformer(JOIN * join, Comp_creator *func)
1174
1128
{
1175
 
  Select_Lex *select_lex= join->select_lex;
 
1129
  SELECT_LEX *select_lex= join->select_lex;
1176
1130
 
1177
 
  select_lex->uncacheable.set(UNCACHEABLE_DEPENDENT);
 
1131
  select_lex->uncacheable|= UNCACHEABLE_DEPENDENT;
1178
1132
  if (join->having || select_lex->with_sum_func ||
1179
1133
      select_lex->group_list.elements)
1180
1134
  {
1188
1142
                                                      this->full_name()));
1189
1143
    if (!abort_on_null && left_expr->maybe_null)
1190
1144
    {
1191
 
      /*
 
1145
      /* 
1192
1146
        We can encounter "NULL IN (SELECT ...)". Wrap the added condition
1193
1147
        within a trig_cond.
1194
1148
      */
1195
1149
      item= new Item_func_trig_cond(item, get_cond_guard(0));
1196
1150
    }
1197
 
 
 
1151
    
1198
1152
    /*
1199
1153
      AND and comparison functions can't be changed during fix_fields()
1200
1154
      we can assign select_lex->having here, and pass 0 as last
1208
1162
      we do not check join->having->fixed, because Item_and (from and_items)
1209
1163
      or comparison function (from func->create) can't be fixed after creation
1210
1164
    */
1211
 
    tmp= join->having->fix_fields(session, 0);
 
1165
    tmp= join->having->fix_fields(thd, 0);
1212
1166
    select_lex->having_fix_field= 0;
1213
1167
    if (tmp)
1214
1168
      return(RES_ERROR);
1226
1180
                                                   (int64_t) 1,
1227
1181
                                                   MY_INT64_NUM_DECIMAL_DIGITS));
1228
1182
      select_lex->ref_pointer_array[0]= select_lex->item_list.head();
1229
 
 
 
1183
       
1230
1184
      item= func->create(expr, item);
1231
1185
      if (!abort_on_null && orig_item->maybe_null)
1232
1186
      {
1250
1204
          and_items) or comparison function (from func->create) can't be
1251
1205
          fixed after creation
1252
1206
        */
1253
 
        tmp= join->having->fix_fields(session, 0);
 
1207
        tmp= join->having->fix_fields(thd, 0);
1254
1208
        select_lex->having_fix_field= 0;
1255
1209
        if (tmp)
1256
1210
          return(RES_ERROR);
1257
1211
        item= new Item_cond_or(item,
1258
1212
                               new Item_func_isnull(orig_item));
1259
1213
      }
1260
 
      /*
 
1214
      /* 
1261
1215
        If we may encounter NULL IN (SELECT ...) and care whether subquery
1262
1216
        result is NULL or false, wrap condition in a trig_cond.
1263
1217
      */
1267
1221
          return(RES_ERROR);
1268
1222
      }
1269
1223
      /*
1270
 
        TODO: figure out why the following is done here in
 
1224
        TODO: figure out why the following is done here in 
1271
1225
        single_value_transformer but there is no corresponding action in
1272
1226
        row_value_transformer?
1273
1227
      */
1284
1238
        we do not check join->conds->fixed, because Item_and can't be fixed
1285
1239
        after creation
1286
1240
      */
1287
 
      if (join->conds->fix_fields(session, 0))
 
1241
      if (join->conds->fix_fields(thd, 0))
1288
1242
        return(RES_ERROR);
1289
1243
    }
1290
1244
    else
1312
1266
        new_having->name= (char*)in_having_cond;
1313
1267
        select_lex->having= join->having= new_having;
1314
1268
        select_lex->having_fix_field= 1;
1315
 
 
 
1269
        
1316
1270
        /*
1317
1271
          we do not check join->having->fixed, because comparison function
1318
1272
          (from func->create) can't be fixed after creation
1319
1273
        */
1320
 
        tmp= join->having->fix_fields(session, 0);
 
1274
        tmp= join->having->fix_fields(thd, 0);
1321
1275
        select_lex->having_fix_field= 0;
1322
1276
        if (tmp)
1323
1277
          return(RES_ERROR);
1329
1283
        // fix_field of item will be done in time of substituting
1330
1284
        substitution= item;
1331
1285
        have_to_be_excluded= 1;
1332
 
        if (session->lex->describe)
 
1286
        if (thd->lex->describe)
1333
1287
        {
1334
1288
          char warn_buff[DRIZZLE_ERRMSG_SIZE];
1335
 
          snprintf(warn_buff, sizeof(warn_buff), ER(ER_SELECT_REDUCED), select_lex->select_number);
1336
 
          push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
1289
          sprintf(warn_buff, ER(ER_SELECT_REDUCED), select_lex->select_number);
 
1290
          push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1337
1291
                       ER_SELECT_REDUCED, warn_buff);
1338
1292
        }
1339
1293
        return(RES_REDUCE);
1346
1300
 
1347
1301
 
1348
1302
Item_subselect::trans_res
1349
 
Item_in_subselect::row_value_transformer(Join *join)
 
1303
Item_in_subselect::row_value_transformer(JOIN *join)
1350
1304
{
1351
 
  Select_Lex *select_lex= join->select_lex;
1352
 
  uint32_t cols_num= left_expr->cols();
 
1305
  SELECT_LEX *select_lex= join->select_lex;
 
1306
  uint cols_num= left_expr->cols();
1353
1307
 
1354
1308
  if (select_lex->item_list.elements != left_expr->cols())
1355
1309
  {
1364
1318
  if (!substitution)
1365
1319
  {
1366
1320
    //first call for this unit
1367
 
    Select_Lex_Unit *master_unit= select_lex->master_unit();
 
1321
    SELECT_LEX_UNIT *master_unit= select_lex->master_unit();
1368
1322
    substitution= optimizer;
1369
1323
 
1370
 
    Select_Lex *current= session->lex->current_select, *up;
1371
 
    session->lex->current_select= up= current->return_after_parsing();
 
1324
    SELECT_LEX *current= thd->lex->current_select, *up;
 
1325
    thd->lex->current_select= up= current->return_after_parsing();
1372
1326
    //optimizer never use Item **ref => we can pass 0 as parameter
1373
 
    if (!optimizer || optimizer->fix_left(session, 0))
 
1327
    if (!optimizer || optimizer->fix_left(thd, 0))
1374
1328
    {
1375
 
      session->lex->current_select= current;
 
1329
      thd->lex->current_select= current;
1376
1330
      return(RES_ERROR);
1377
1331
    }
1378
1332
 
1379
1333
    // we will refer to upper level cache array => we have to save it in PS
1380
1334
    optimizer->keep_top_level_cache();
1381
1335
 
1382
 
    session->lex->current_select= current;
1383
 
    master_unit->uncacheable.set(UNCACHEABLE_DEPENDENT);
 
1336
    thd->lex->current_select= current;
 
1337
    master_unit->uncacheable|= UNCACHEABLE_DEPENDENT;
1384
1338
 
1385
1339
    if (!abort_on_null && left_expr->maybe_null && !pushed_cond_guards)
1386
1340
    {
1387
 
      if (!(pushed_cond_guards= (bool*)join->session->getMemRoot()->allocate(sizeof(bool) *
 
1341
      if (!(pushed_cond_guards= (bool*)join->thd->alloc(sizeof(bool) *
1388
1342
                                                        left_expr->cols())))
1389
1343
        return(RES_ERROR);
1390
 
      for (uint32_t i= 0; i < cols_num; i++)
 
1344
      for (uint i= 0; i < cols_num; i++)
1391
1345
        pushed_cond_guards[i]= true;
1392
1346
    }
1393
1347
  }
1423
1377
*/
1424
1378
 
1425
1379
Item_subselect::trans_res
1426
 
Item_in_subselect::row_value_in_to_exists_transformer(Join * join)
 
1380
Item_in_subselect::row_value_in_to_exists_transformer(JOIN * join)
1427
1381
{
1428
 
  Select_Lex *select_lex= join->select_lex;
 
1382
  SELECT_LEX *select_lex= join->select_lex;
1429
1383
  Item *having_item= 0;
1430
 
  uint32_t cols_num= left_expr->cols();
 
1384
  uint cols_num= left_expr->cols();
1431
1385
  bool is_having_used= (join->having || select_lex->with_sum_func ||
1432
1386
                        select_lex->group_list.first ||
1433
1387
                        !select_lex->table_list.elements);
1434
1388
 
1435
 
  select_lex->uncacheable.set(UNCACHEABLE_DEPENDENT);
 
1389
  select_lex->uncacheable|= UNCACHEABLE_DEPENDENT;
1436
1390
  if (is_having_used)
1437
1391
  {
1438
1392
    /*
1449
1403
      TODO: say here explicitly if the order of AND parts matters or not.
1450
1404
    */
1451
1405
    Item *item_having_part2= 0;
1452
 
    for (uint32_t i= 0; i < cols_num; i++)
 
1406
    for (uint i= 0; i < cols_num; i++)
1453
1407
    {
1454
1408
      assert((left_expr->fixed && select_lex->ref_pointer_array[i]->fixed) ||
1455
1409
                  (select_lex->ref_pointer_array[i]->type() == REF_ITEM &&
1485
1439
          return(RES_ERROR);
1486
1440
      }
1487
1441
      having_item= and_items(having_item, col_item);
1488
 
 
1489
 
      Item *item_nnull_test=
 
1442
      
 
1443
      Item *item_nnull_test= 
1490
1444
         new Item_is_not_null_test(this,
1491
1445
                                   new Item_ref(&select_lex->context,
1492
1446
                                                select_lex->
1495
1449
                                                (char *)"<list ref>"));
1496
1450
      if (!abort_on_null && left_expr->element_index(i)->maybe_null)
1497
1451
      {
1498
 
        if (!(item_nnull_test=
 
1452
        if (!(item_nnull_test= 
1499
1453
              new Item_func_trig_cond(item_nnull_test, get_cond_guard(i))))
1500
1454
          return(RES_ERROR);
1501
1455
      }
1525
1479
                               (l3 = v3)
1526
1480
    */
1527
1481
    Item *where_item= 0;
1528
 
    for (uint32_t i= 0; i < cols_num; i++)
 
1482
    for (uint i= 0; i < cols_num; i++)
1529
1483
    {
1530
1484
      Item *item, *item_isnull;
1531
1485
      assert((left_expr->fixed && select_lex->ref_pointer_array[i]->fixed) ||
1554
1508
        Item *having_col_item=
1555
1509
          new Item_is_not_null_test(this,
1556
1510
                                    new
1557
 
                                    Item_ref(&select_lex->context,
 
1511
                                    Item_ref(&select_lex->context, 
1558
1512
                                             select_lex->ref_pointer_array + i,
1559
1513
                                             (char *)"<no matter>",
1560
1514
                                             (char *)"<list ref>"));
1561
 
 
1562
 
 
 
1515
        
 
1516
        
1563
1517
        item_isnull= new
1564
1518
          Item_func_isnull(new
1565
1519
                           Item_direct_ref(&select_lex->context,
1569
1523
                                           (char *)"<list ref>")
1570
1524
                          );
1571
1525
        item= new Item_cond_or(item, item_isnull);
1572
 
        /*
 
1526
        /* 
1573
1527
          TODO: why we create the above for cases where the right part
1574
1528
                cant be NULL?
1575
1529
        */
1577
1531
        {
1578
1532
          if (!(item= new Item_func_trig_cond(item, get_cond_guard(i))))
1579
1533
            return(RES_ERROR);
1580
 
          if (!(having_col_item=
 
1534
          if (!(having_col_item= 
1581
1535
                  new Item_func_trig_cond(having_col_item, get_cond_guard(i))))
1582
1536
            return(RES_ERROR);
1583
1537
        }
1592
1546
    */
1593
1547
    select_lex->where= join->conds= and_items(join->conds, where_item);
1594
1548
    select_lex->where->top_level_item();
1595
 
    if (join->conds->fix_fields(session, 0))
 
1549
    if (join->conds->fix_fields(thd, 0))
1596
1550
      return(RES_ERROR);
1597
1551
  }
1598
1552
  if (having_item)
1608
1562
      argument (reference) to fix_fields()
1609
1563
    */
1610
1564
    select_lex->having_fix_field= 1;
1611
 
    res= join->having->fix_fields(session, 0);
 
1565
    res= join->having->fix_fields(thd, 0);
1612
1566
    select_lex->having_fix_field= 0;
1613
1567
    if (res)
1614
1568
    {
1621
1575
 
1622
1576
 
1623
1577
Item_subselect::trans_res
1624
 
Item_in_subselect::select_transformer(Join *join)
 
1578
Item_in_subselect::select_transformer(JOIN *join)
1625
1579
{
1626
 
  return select_in_like_transformer(join, Eq_creator::instance());
 
1580
  return select_in_like_transformer(join, &eq_creator);
1627
1581
}
1628
1582
 
1629
1583
 
1649
1603
*/
1650
1604
 
1651
1605
Item_subselect::trans_res
1652
 
Item_in_subselect::select_in_like_transformer(Join *join, const Comp_creator *func)
 
1606
Item_in_subselect::select_in_like_transformer(JOIN *join, Comp_creator *func)
1653
1607
{
1654
 
  Select_Lex *current= session->lex->current_select, *up;
1655
 
  const char *save_where= session->where();
 
1608
  SELECT_LEX *current= thd->lex->current_select, *up;
 
1609
  const char *save_where= thd->where;
1656
1610
  Item_subselect::trans_res res= RES_ERROR;
1657
1611
  bool result;
1658
1612
 
1659
1613
  {
1660
1614
    /*
1661
1615
      IN/SOME/ALL/ANY subqueries aren't support LIMIT clause. Without it
1662
 
      ORDER BY clause becomes meaningless thus we drop it here.
 
1616
      order_st BY clause becomes meaningless thus we drop it here.
1663
1617
    */
1664
 
    Select_Lex *sl= current->master_unit()->first_select();
 
1618
    SELECT_LEX *sl= current->master_unit()->first_select();
1665
1619
    for (; sl; sl= sl->next_select())
1666
1620
    {
1667
1621
      if (sl->join)
1672
1626
  if (changed)
1673
1627
    return(RES_OK);
1674
1628
 
1675
 
  session->setWhere("IN/ALL/ANY subquery");
 
1629
  thd->where= "IN/ALL/ANY subquery";
1676
1630
 
1677
1631
  /*
1678
1632
    In some optimisation cases we will not need this Item_in_optimizer
1686
1640
      goto err;
1687
1641
  }
1688
1642
 
1689
 
  session->lex->current_select= up= current->return_after_parsing();
 
1643
  thd->lex->current_select= up= current->return_after_parsing();
1690
1644
  result= (!left_expr->fixed &&
1691
 
           left_expr->fix_fields(session, optimizer->arguments()));
 
1645
           left_expr->fix_fields(thd, optimizer->arguments()));
1692
1646
  /* fix_fields can change reference to left_expr, we need reassign it */
1693
1647
  left_expr= optimizer->arguments()[0];
1694
1648
 
1695
 
  session->lex->current_select= current;
 
1649
  thd->lex->current_select= current;
1696
1650
  if (result)
1697
1651
    goto err;
1698
1652
 
1715
1669
  else
1716
1670
  {
1717
1671
    /* we do not support row operation for ALL/ANY/SOME */
1718
 
    if (func != Eq_creator::instance())
 
1672
    if (func != &eq_creator)
1719
1673
    {
1720
1674
      my_error(ER_OPERAND_COLUMNS, MYF(0), 1);
1721
1675
      return(RES_ERROR);
1723
1677
    res= row_value_transformer(join);
1724
1678
  }
1725
1679
err:
1726
 
  session->setWhere(save_where);
 
1680
  thd->where= save_where;
1727
1681
  return(res);
1728
1682
}
1729
1683
 
1741
1695
}
1742
1696
 
1743
1697
 
1744
 
bool Item_in_subselect::fix_fields(Session *session_arg, Item **ref)
 
1698
bool Item_in_subselect::fix_fields(THD *thd_arg, Item **ref)
1745
1699
{
1746
1700
  bool result = 0;
1747
1701
 
1748
1702
  if (exec_method == SEMI_JOIN)
1749
1703
    return !( (*ref)= new Item_int(1));
1750
1704
 
1751
 
  return result || Item_subselect::fix_fields(session_arg, ref);
 
1705
  return result || Item_subselect::fix_fields(thd_arg, ref);
1752
1706
}
1753
1707
 
1754
1708
 
1784
1738
  if (engine->engine_type() == subselect_engine::SINGLE_SELECT_ENGINE)
1785
1739
  {
1786
1740
    /* Create/initialize objects in permanent memory. */
1787
 
    subselect_single_select_engine *old_engine_ptr;
1788
 
 
1789
 
    old_engine_ptr= static_cast<subselect_single_select_engine *>(engine);
1790
 
 
1791
 
    if (!(new_engine= new subselect_hash_sj_engine(session, this,
1792
 
                                                   old_engine_ptr)) ||
 
1741
    subselect_single_select_engine *old_engine;
 
1742
 
 
1743
    old_engine= (subselect_single_select_engine*) engine;
 
1744
 
 
1745
    if (!(new_engine= new subselect_hash_sj_engine(thd, this,
 
1746
                                                   old_engine)) ||
1793
1747
        new_engine->init_permanent(unit->get_unit_column_types()))
1794
1748
    {
1795
 
      Item_subselect::trans_res new_trans_res;
 
1749
      Item_subselect::trans_res trans_res;
1796
1750
      /*
1797
1751
        If for some reason we cannot use materialization for this IN predicate,
1798
1752
        delete all materialization-related objects, and apply the IN=>EXISTS
1802
1756
      new_engine= NULL;
1803
1757
      exec_method= NOT_TRANSFORMED;
1804
1758
      if (left_expr->cols() == 1)
1805
 
        new_trans_res= single_value_in_to_exists_transformer(
1806
 
                           old_engine_ptr->join,
1807
 
                           Eq_creator::instance());
 
1759
        trans_res= single_value_in_to_exists_transformer(old_engine->join,
 
1760
                                                         &eq_creator);
1808
1761
      else
1809
 
        new_trans_res= row_value_in_to_exists_transformer(old_engine_ptr->join);
1810
 
      res= (new_trans_res != Item_subselect::RES_OK);
 
1762
        trans_res= row_value_in_to_exists_transformer(old_engine->join);
 
1763
      res= (trans_res != Item_subselect::RES_OK);
1811
1764
    }
1812
1765
    if (new_engine)
1813
1766
      engine= new_engine;
1815
1768
  else
1816
1769
  {
1817
1770
    assert(engine->engine_type() == subselect_engine::HASH_SJ_ENGINE);
1818
 
    new_engine= static_cast<subselect_hash_sj_engine *>(engine);
 
1771
    new_engine= (subselect_hash_sj_engine*) engine;
1819
1772
  }
1820
1773
 
1821
1774
  /* Initilizations done in runtime memory, repeated for each execution. */
1852
1805
 
1853
1806
bool Item_in_subselect::init_left_expr_cache()
1854
1807
{
1855
 
  Join *outer_join= NULL;
 
1808
  JOIN *outer_join;
 
1809
  Next_select_func end_select;
 
1810
  bool use_result_field= false;
1856
1811
 
1857
1812
  outer_join= unit->outer_select()->join;
1858
 
  if (! outer_join || ! outer_join->tables || ! outer_join->join_tab)
 
1813
  if (!outer_join || !outer_join->tables)
1859
1814
    return true;
 
1815
  /*
 
1816
    If we use end_[send | write]_group to handle complete rows of the outer
 
1817
    query, make the cache of the left IN operand use Item_field::result_field
 
1818
    instead of Item_field::field.  We need this because normally
 
1819
    Cached_item_field uses Item::field to fetch field data, while
 
1820
    copy_ref_key() that copies the left IN operand into a lookup key uses
 
1821
    Item::result_field. In the case end_[send | write]_group result_field is
 
1822
    one row behind field.
 
1823
  */
 
1824
  end_select= outer_join->join_tab[outer_join->tables-1].next_select;
 
1825
  if (end_select == end_send_group || end_select == end_write_group)
 
1826
    use_result_field= true;
1860
1827
 
1861
1828
  if (!(left_expr_cache= new List<Cached_item>))
1862
1829
    return true;
1863
1830
 
1864
 
  for (uint32_t i= 0; i < left_expr->cols(); i++)
 
1831
  for (uint i= 0; i < left_expr->cols(); i++)
1865
1832
  {
1866
 
    Cached_item *cur_item_cache= new_Cached_item(session, left_expr->element_index(i));
 
1833
    Cached_item *cur_item_cache= new_Cached_item(thd,
 
1834
                                                 left_expr->element_index(i),
 
1835
                                                 use_result_field);
1867
1836
    if (!cur_item_cache || left_expr_cache->push_front(cur_item_cache))
1868
1837
      return true;
1869
1838
  }
1884
1853
  @retval false otherwise
1885
1854
*/
1886
1855
 
1887
 
bool Item_in_subselect::is_expensive_processor(unsigned char *)
 
1856
bool Item_in_subselect::is_expensive_processor(uchar *arg __attribute__((unused)))
1888
1857
{
1889
1858
  return exec_method == MATERIALIZATION;
1890
1859
}
1891
1860
 
1892
1861
 
1893
1862
Item_subselect::trans_res
1894
 
Item_allany_subselect::select_transformer(Join *join)
 
1863
Item_allany_subselect::select_transformer(JOIN *join)
1895
1864
{
1896
1865
  exec_method= IN_TO_EXISTS;
1897
1866
  if (upper_item)
1915
1884
}
1916
1885
 
1917
1886
 
1918
 
void subselect_engine::set_session(Session *session_arg)
 
1887
void subselect_engine::set_thd(THD *thd_arg)
1919
1888
{
1920
 
  session= session_arg;
 
1889
  thd= thd_arg;
1921
1890
  if (result)
1922
 
    result->set_session(session_arg);
 
1891
    result->set_thd(thd_arg);
1923
1892
}
1924
1893
 
1925
1894
 
1926
1895
subselect_single_select_engine::
1927
 
subselect_single_select_engine(Select_Lex *select,
 
1896
subselect_single_select_engine(st_select_lex *select,
1928
1897
                               select_result_interceptor *result_arg,
1929
1898
                               Item_subselect *item_arg)
1930
1899
  :subselect_engine(item_arg, result_arg),
1982
1951
void subselect_uniquesubquery_engine::cleanup()
1983
1952
{
1984
1953
  /* Tell handler we don't need the index anymore */
1985
 
  if (tab->table->cursor->inited)
1986
 
    tab->table->cursor->endIndexScan();
 
1954
  if (tab->table->file->inited)
 
1955
    tab->table->file->ha_index_end();
1987
1956
  return;
1988
1957
}
1989
1958
 
1990
1959
 
1991
 
subselect_union_engine::subselect_union_engine(Select_Lex_Unit *u,
 
1960
subselect_union_engine::subselect_union_engine(st_select_lex_unit *u,
1992
1961
                                               select_result_interceptor *result_arg,
1993
1962
                                               Item_subselect *item_arg)
1994
1963
  :subselect_engine(item_arg, result_arg)
2028
1997
{
2029
1998
  if (prepared)
2030
1999
    return 0;
2031
 
  join= new Join(session, select_lex->item_list,
 
2000
  join= new JOIN(thd, select_lex->item_list,
2032
2001
                 select_lex->options | SELECT_NO_UNLOCK, result);
2033
2002
  if (!join || !result)
2034
2003
    return 1; /* Fatal error is set already. */
2035
2004
  prepared= 1;
2036
 
  Select_Lex *save_select= session->lex->current_select;
2037
 
  session->lex->current_select= select_lex;
 
2005
  SELECT_LEX *save_select= thd->lex->current_select;
 
2006
  thd->lex->current_select= select_lex;
2038
2007
  if (join->prepare(&select_lex->ref_pointer_array,
2039
2008
                    (TableList*) select_lex->table_list.first,
2040
2009
                    select_lex->with_wild,
2041
2010
                    select_lex->where,
2042
2011
                    select_lex->order_list.elements +
2043
2012
                    select_lex->group_list.elements,
2044
 
                    (Order*) select_lex->order_list.first,
2045
 
                    (Order*) select_lex->group_list.first,
 
2013
                    (order_st*) select_lex->order_list.first,
 
2014
                    (order_st*) select_lex->group_list.first,
2046
2015
                    select_lex->having,
2047
 
                    select_lex, select_lex->master_unit()))
 
2016
                    (order_st*) 0, select_lex,
 
2017
                    select_lex->master_unit()))
2048
2018
    return 1;
2049
 
  session->lex->current_select= save_select;
 
2019
  thd->lex->current_select= save_select;
2050
2020
  return 0;
2051
2021
}
2052
2022
 
2053
2023
int subselect_union_engine::prepare()
2054
2024
{
2055
 
  return unit->prepare(session, result, (uint32_t)SELECT_NO_UNLOCK);
 
2025
  return unit->prepare(thd, result, SELECT_NO_UNLOCK);
2056
2026
}
2057
2027
 
2058
2028
int subselect_uniquesubquery_engine::prepare()
2079
2049
*/
2080
2050
 
2081
2051
bool subselect_single_select_engine::no_rows()
2082
 
{
 
2052
{ 
2083
2053
  return !item->assigned();
2084
2054
}
2085
2055
 
2086
2056
 
2087
 
/*
2088
 
 makes storage for the output values for the subquery and calcuates
 
2057
/* 
 
2058
 makes storage for the output values for the subquery and calcuates 
2089
2059
 their data and column types and their nullability.
2090
 
*/
 
2060
*/ 
2091
2061
void subselect_engine::set_row(List<Item> &item_list, Item_cache **row)
2092
2062
{
2093
2063
  Item *sel_item;
2094
2064
  List_iterator_fast<Item> li(item_list);
2095
2065
  res_type= STRING_RESULT;
2096
2066
  res_field_type= DRIZZLE_TYPE_VARCHAR;
2097
 
  for (uint32_t i= 0; (sel_item= li++); i++)
 
2067
  for (uint i= 0; (sel_item= li++); i++)
2098
2068
  {
2099
2069
    item->max_length= sel_item->max_length;
2100
2070
    res_type= sel_item->result_type();
2136
2106
  }
2137
2107
}
2138
2108
 
2139
 
void subselect_uniquesubquery_engine::fix_length_and_dec(Item_cache **)
 
2109
void subselect_uniquesubquery_engine::fix_length_and_dec(Item_cache **row __attribute__((unused)))
2140
2110
{
2141
2111
  //this never should be called
2142
2112
  assert(0);
2143
2113
}
2144
2114
 
 
2115
int  init_read_record_seq(JOIN_TAB *tab);
 
2116
int join_read_always_key_or_null(JOIN_TAB *tab);
 
2117
int join_read_next_same_or_null(READ_RECORD *info);
 
2118
 
2145
2119
int subselect_single_select_engine::exec()
2146
2120
{
2147
 
  char const *save_where= session->where();
2148
 
  Select_Lex *save_select= session->lex->current_select;
2149
 
  session->lex->current_select= select_lex;
 
2121
  char const *save_where= thd->where;
 
2122
  SELECT_LEX *save_select= thd->lex->current_select;
 
2123
  thd->lex->current_select= select_lex;
2150
2124
  if (!join->optimized)
2151
2125
  {
2152
 
    Select_Lex_Unit *unit= select_lex->master_unit();
 
2126
    SELECT_LEX_UNIT *unit= select_lex->master_unit();
2153
2127
 
2154
2128
    unit->set_limit(unit->global_parameters);
 
2129
    if (join->flatten_subqueries())
 
2130
    {
 
2131
      thd->is_fatal_error= true;
 
2132
      return(1);
 
2133
    }
2155
2134
    if (join->optimize())
2156
2135
    {
2157
 
      session->setWhere(save_where);
 
2136
      thd->where= save_where;
2158
2137
      executed= 1;
2159
 
      session->lex->current_select= save_select;
 
2138
      thd->lex->current_select= save_select;
2160
2139
      return(join->error ? join->error : 1);
2161
2140
    }
2162
 
    if (save_join_if_explain())
2163
 
     return(1);
2164
 
 
 
2141
    if (!select_lex->uncacheable && thd->lex->describe && 
 
2142
        !(join->select_options & SELECT_DESCRIBE) && 
 
2143
        join->need_tmp && item->const_item())
 
2144
    {
 
2145
      /*
 
2146
        Force join->join_tmp creation, because this subquery will be replaced
 
2147
        by a simple select from the materialization temp table by optimize()
 
2148
        called by EXPLAIN and we need to preserve the initial query structure
 
2149
        so we can display it.
 
2150
       */
 
2151
      select_lex->uncacheable|= UNCACHEABLE_EXPLAIN;
 
2152
      select_lex->master_unit()->uncacheable|= UNCACHEABLE_EXPLAIN;
 
2153
      if (join->init_save_join_tab())
 
2154
        return(1);                        /* purecov: inspected */
 
2155
    }
2165
2156
    if (item->engine_changed)
2166
2157
    {
2167
2158
      return(1);
2168
2159
    }
2169
2160
  }
2170
 
  if (select_lex->uncacheable.any() &&
2171
 
      ! select_lex->uncacheable.test(UNCACHEABLE_EXPLAIN) &&
2172
 
      executed)
 
2161
  if (select_lex->uncacheable &&
 
2162
      select_lex->uncacheable != UNCACHEABLE_EXPLAIN
 
2163
      && executed)
2173
2164
  {
2174
2165
    if (join->reinit())
2175
2166
    {
2176
 
      session->setWhere(save_where);
2177
 
      session->lex->current_select= save_select;
2178
 
      return 1;
 
2167
      thd->where= save_where;
 
2168
      thd->lex->current_select= save_select;
 
2169
      return(1);
2179
2170
    }
2180
2171
    item->reset();
2181
2172
    item->assigned((executed= 0));
2183
2174
  if (!executed)
2184
2175
  {
2185
2176
    item->reset_value_registration();
2186
 
    JoinTable *changed_tabs[MAX_TABLES];
2187
 
    JoinTable **last_changed_tab= changed_tabs;
 
2177
    JOIN_TAB *changed_tabs[MAX_TABLES];
 
2178
    JOIN_TAB **last_changed_tab= changed_tabs;
2188
2179
    if (item->have_guarded_conds())
2189
2180
    {
2190
2181
      /*
2193
2184
        pushed down into the subquery. Those optimizations are ref[_or_null]
2194
2185
        acceses. Change them to be full table scans.
2195
2186
      */
2196
 
      for (uint32_t i=join->const_tables ; i < join->tables ; i++)
 
2187
      for (uint i=join->const_tables ; i < join->tables ; i++)
2197
2188
      {
2198
 
        JoinTable *tab=join->join_tab+i;
 
2189
        JOIN_TAB *tab=join->join_tab+i;
2199
2190
        if (tab && tab->keyuse)
2200
2191
        {
2201
 
          for (uint32_t key_part= 0;
2202
 
               key_part < tab->ref.key_parts;
2203
 
               key_part++)
 
2192
          for (uint i= 0; i < tab->ref.key_parts; i++)
2204
2193
          {
2205
 
            bool *cond_guard= tab->ref.cond_guards[key_part];
 
2194
            bool *cond_guard= tab->ref.cond_guards[i];
2206
2195
            if (cond_guard && !*cond_guard)
2207
2196
            {
2208
2197
              /* Change the access method to full table scan */
2210
2199
              tab->save_read_record= tab->read_record.read_record;
2211
2200
              tab->read_first_record= init_read_record_seq;
2212
2201
              tab->read_record.record= tab->table->record[0];
2213
 
              tab->read_record.session= join->session;
2214
 
              tab->read_record.ref_length= tab->table->cursor->ref_length;
 
2202
              tab->read_record.thd= join->thd;
 
2203
              tab->read_record.ref_length= tab->table->file->ref_length;
2215
2204
              *(last_changed_tab++)= tab;
2216
2205
              break;
2217
2206
            }
2219
2208
        }
2220
2209
      }
2221
2210
    }
2222
 
 
 
2211
    
2223
2212
    join->exec();
2224
2213
 
2225
2214
    /* Enable the optimizations back */
2226
 
    for (JoinTable **ptab= changed_tabs; ptab != last_changed_tab; ptab++)
 
2215
    for (JOIN_TAB **ptab= changed_tabs; ptab != last_changed_tab; ptab++)
2227
2216
    {
2228
 
      JoinTable *tab= *ptab;
 
2217
      JOIN_TAB *tab= *ptab;
2229
2218
      tab->read_record.record= 0;
2230
2219
      tab->read_record.ref_length= 0;
2231
 
      tab->read_first_record= tab->save_read_first_record;
 
2220
      tab->read_first_record= tab->save_read_first_record; 
2232
2221
      tab->read_record.read_record= tab->save_read_record;
2233
2222
    }
2234
2223
    executed= 1;
2235
 
    session->setWhere(save_where);
2236
 
    session->lex->current_select= save_select;
2237
 
    return(join->error||session->is_fatal_error);
 
2224
    thd->where= save_where;
 
2225
    thd->lex->current_select= save_select;
 
2226
    return(join->error||thd->is_fatal_error);
2238
2227
  }
2239
 
  session->setWhere(save_where);
2240
 
  session->lex->current_select= save_select;
 
2228
  thd->where= save_where;
 
2229
  thd->lex->current_select= save_select;
2241
2230
  return(0);
2242
2231
}
2243
2232
 
2244
 
bool 
2245
 
subselect_single_select_engine::save_join_if_explain()
2246
 
{
2247
 
  /*
2248
 
    Save this JOIN to join->tmp_join since the original layout will be
2249
 
    replaced when JOIN::exec() calls make_simple_join() if:
2250
 
     1) We are executing an EXPLAIN query
2251
 
     2) An uncacheable flag has not been set for the select_lex. If
2252
 
        set, JOIN::optimize() has already saved the JOIN
2253
 
     3) Call does not come from select_describe()). If it does,
2254
 
        JOIN::exec() will not call make_simple_join() and the JOIN we
2255
 
        plan to save will not be replaced anyway.
2256
 
     4) A temp table is needed. This is what triggers JOIN::exec() to
2257
 
        make a replacement JOIN by calling make_simple_join(). 
2258
 
     5) The Item_subselect is cacheable
2259
 
  */
2260
 
  if (session->lex->describe &&                          // 1
2261
 
      select_lex->uncacheable.none() &&                  // 2
2262
 
      !(join->select_options & SELECT_DESCRIBE) &&       // 3
2263
 
      join->need_tmp &&                                  // 4
2264
 
      item->const_item())                                // 5
2265
 
  {
2266
 
    /*
2267
 
      Save this JOIN to join->tmp_join since the original layout will
2268
 
      be replaced when JOIN::exec() calls make_simple_join() due to
2269
 
      need_tmp==TRUE. The original layout is needed so we can describe
2270
 
      the query. No need to do this if uncacheable != 0 since in this
2271
 
      case the JOIN has already been saved during JOIN::optimize()
2272
 
    */
2273
 
    select_lex->uncacheable.set(UNCACHEABLE_EXPLAIN);
2274
 
    select_lex->master_unit()->uncacheable.set(UNCACHEABLE_EXPLAIN);
2275
 
    if (join->init_save_join_tab())
2276
 
      return true;
2277
 
  }
2278
 
  return false;
2279
 
}
2280
 
 
2281
 
 
2282
2233
int subselect_union_engine::exec()
2283
2234
{
2284
 
  char const *save_where= session->where();
 
2235
  char const *save_where= thd->where;
2285
2236
  int res= unit->exec();
2286
 
  session->setWhere(save_where);
2287
 
 
 
2237
  thd->where= save_where;
2288
2238
  return res;
2289
2239
}
2290
2240
 
2291
2241
 
2292
2242
/*
2293
2243
  Search for at least one row satisfying select condition
2294
 
 
 
2244
 
2295
2245
  SYNOPSIS
2296
2246
    subselect_uniquesubquery_engine::scan_table()
2297
2247
 
2298
2248
  DESCRIPTION
2299
2249
    Scan the table using sequential access until we find at least one row
2300
2250
    satisfying select condition.
2301
 
 
 
2251
    
2302
2252
    The caller must set this->empty_result_set=false before calling this
2303
2253
    function. This function will set it to true if it finds a matching row.
2304
2254
 
2312
2262
  int error;
2313
2263
  Table *table= tab->table;
2314
2264
 
2315
 
  if (table->cursor->inited)
2316
 
    table->cursor->endIndexScan();
2317
 
 
2318
 
  if ((error= table->cursor->startTableScan(1)))
2319
 
  {
2320
 
    table->print_error(error, MYF(0));
2321
 
    return 1;
2322
 
  }
2323
 
 
2324
 
  assert(table->getSession());
2325
 
  table->cursor->extra_opt(HA_EXTRA_CACHE,
2326
 
                           table->getSession()->variables.read_buff_size);
 
2265
  if (table->file->inited)
 
2266
    table->file->ha_index_end();
 
2267
 
 
2268
  table->file->ha_rnd_init(1);
 
2269
  table->file->extra_opt(HA_EXTRA_CACHE,
 
2270
                         current_thd->variables.read_buff_size);
2327
2271
  table->null_row= 0;
2328
2272
  for (;;)
2329
2273
  {
2330
 
    error=table->cursor->rnd_next(table->record[0]);
 
2274
    error=table->file->rnd_next(table->record[0]);
2331
2275
    if (error && error != HA_ERR_END_OF_FILE)
2332
2276
    {
2333
2277
      error= table->report_error(error);
2344
2288
    }
2345
2289
  }
2346
2290
 
2347
 
  table->cursor->endTableScan();
 
2291
  table->file->ha_rnd_end();
2348
2292
  return(error != 0);
2349
2293
}
2350
2294
 
2393
2337
 
2394
2338
bool subselect_uniquesubquery_engine::copy_ref_key()
2395
2339
{
2396
 
  for (StoredKey **copy= tab->ref.key_copy ; *copy ; copy++)
 
2340
  for (store_key **copy= tab->ref.key_copy ; *copy ; copy++)
2397
2341
  {
2398
 
    StoredKey::store_key_result store_res= (*copy)->copy();
 
2342
    enum store_key::store_key_result store_res;
 
2343
    store_res= (*copy)->copy();
2399
2344
    tab->ref.key_err= store_res;
2400
2345
 
2401
2346
    /*
2423
2368
    }
2424
2369
 
2425
2370
    /*
2426
 
      Check if the error is equal to STORE_KEY_FATAL. This is not expressed
2427
 
      using the StoredKey::store_key_result enum because ref.key_err is a
2428
 
      boolean and we want to detect both true and STORE_KEY_FATAL from the
2429
 
      space of the union of the values of [true, false] and
2430
 
      StoredKey::store_key_result.
 
2371
      Check if the error is equal to STORE_KEY_FATAL. This is not expressed 
 
2372
      using the store_key::store_key_result enum because ref.key_err is a 
 
2373
      boolean and we want to detect both true and STORE_KEY_FATAL from the 
 
2374
      space of the union of the values of [true, false] and 
 
2375
      store_key::store_key_result.  
2431
2376
      TODO: fix the variable an return types.
2432
2377
    */
2433
 
    if (store_res == StoredKey::STORE_KEY_FATAL)
 
2378
    if (store_res == store_key::STORE_KEY_FATAL)
2434
2379
    {
2435
2380
      /*
2436
2381
       Error converting the left IN operand to the column type of the right
2437
 
       IN operand.
 
2382
       IN operand. 
2438
2383
      */
2439
2384
      tab->table->status= STATUS_NOT_FOUND;
2440
2385
      break;
2455
2400
    If some part of the lookup key is NULL, then we're evaluating
2456
2401
      NULL IN (SELECT ... )
2457
2402
    This is a special case, we don't need to search for NULL in the table,
2458
 
    instead, the result value is
 
2403
    instead, the result value is 
2459
2404
      - NULL  if select produces empty row set
2460
2405
      - false otherwise.
2461
2406
 
2462
2407
    In some cases (IN subselect is a top level item, i.e. abort_on_null==true)
2463
2408
    the caller doesn't distinguish between NULL and false result and we just
2464
 
    return false.
2465
 
    Otherwise we make a full table scan to see if there is at least one
 
2409
    return false. 
 
2410
    Otherwise we make a full table scan to see if there is at least one 
2466
2411
    matching row.
2467
 
 
 
2412
    
2468
2413
    The result of this function (info about whether a row was found) is
2469
2414
    stored in this->empty_result_set.
2470
2415
  NOTE
2471
 
 
 
2416
    
2472
2417
  RETURN
2473
2418
    false - ok
2474
2419
    true  - an error occured while scanning
2480
2425
  Table *table= tab->table;
2481
2426
  empty_result_set= true;
2482
2427
  table->status= 0;
2483
 
 
 
2428
 
2484
2429
  /* TODO: change to use of 'full_scan' here? */
2485
2430
  if (copy_ref_key())
2486
2431
    return(1);
2487
2432
  if (table->status)
2488
2433
  {
2489
 
    /*
2490
 
      We know that there will be no rows even if we scan.
 
2434
    /* 
 
2435
      We know that there will be no rows even if we scan. 
2491
2436
      Can be set in copy_ref_key.
2492
2437
    */
2493
2438
    ((Item_in_subselect *) item)->value= 0;
2496
2441
 
2497
2442
  if (null_keypart)
2498
2443
    return(scan_table());
2499
 
 
2500
 
  if (!table->cursor->inited)
2501
 
  {
2502
 
    error= table->cursor->startIndexScan(tab->ref.key, 0);
2503
 
 
2504
 
    if (error != 0)
2505
 
    {
2506
 
      error= table->report_error(error);
2507
 
      return (error != 0);
2508
 
    }
2509
 
  }
2510
 
 
2511
 
  error= table->cursor->index_read_map(table->record[0],
 
2444
 
 
2445
  if (!table->file->inited)
 
2446
    table->file->ha_index_init(tab->ref.key, 0);
 
2447
  error= table->file->index_read_map(table->record[0],
2512
2448
                                     tab->ref.key_buff,
2513
2449
                                     make_prev_keypart_map(tab->ref.key_parts),
2514
2450
                                     HA_READ_KEY_EXACT);
2537
2473
 
2538
2474
  SYNOPSIS
2539
2475
    subselect_indexsubquery_engine:exec()
2540
 
      full_scan
 
2476
      full_scan 
2541
2477
 
2542
2478
  DESCRIPTION
2543
2479
    The engine is used to resolve subqueries in form
2544
2480
 
2545
 
      oe IN (SELECT key FROM tbl WHERE subq_where)
 
2481
      oe IN (SELECT key FROM tbl WHERE subq_where) 
2546
2482
 
2547
 
    The value of the predicate is calculated as follows:
 
2483
    The value of the predicate is calculated as follows: 
2548
2484
    1. If oe IS NULL, this is a special case, do a full table scan on
2549
 
       table tbl and search for row that satisfies subq_where. If such
 
2485
       table tbl and search for row that satisfies subq_where. If such 
2550
2486
       row is found, return NULL, otherwise return false.
2551
2487
    2. Make an index lookup via key=oe, search for a row that satisfies
2552
2488
       subq_where. If found, return true.
2553
 
    3. If check_null==true, make another lookup via key=NULL, search for a
 
2489
    3. If check_null==true, make another lookup via key=NULL, search for a 
2554
2490
       row that satisfies subq_where. If found, return NULL, otherwise
2555
2491
       return false.
2556
2492
 
2557
2493
  TODO
2558
2494
    The step #1 can be optimized further when the index has several key
2559
2495
    parts. Consider a subquery:
2560
 
 
 
2496
    
2561
2497
      (oe1, oe2) IN (SELECT keypart1, keypart2 FROM tbl WHERE subq_where)
2562
2498
 
2563
2499
    and suppose we need to evaluate it for {oe1, oe2}=={const1, NULL}.
2567
2503
      SELECT keypart1, keypart2 FROM tbl WHERE subq_where            (1)
2568
2504
 
2569
2505
    and checking if it has produced any matching rows, evaluate
2570
 
 
 
2506
    
2571
2507
      SELECT keypart2 FROM tbl WHERE subq_where AND keypart1=const1  (2)
2572
2508
 
2573
 
    If this query produces a row, the result is NULL (as we're evaluating
 
2509
    If this query produces a row, the result is NULL (as we're evaluating 
2574
2510
    "(const1, NULL) IN { (const1, X), ... }", which has a value of UNKNOWN,
2575
2511
    i.e. NULL).  If the query produces no rows, the result is false.
2576
2512
 
2608
2544
 
2609
2545
  if (table->status)
2610
2546
  {
2611
 
    /*
2612
 
      We know that there will be no rows even if we scan.
 
2547
    /* 
 
2548
      We know that there will be no rows even if we scan. 
2613
2549
      Can be set in copy_ref_key.
2614
2550
    */
2615
2551
    ((Item_in_subselect *) item)->value= 0;
2619
2555
  if (null_keypart)
2620
2556
    return(scan_table());
2621
2557
 
2622
 
  if (!table->cursor->inited)
2623
 
  {
2624
 
    error= table->cursor->startIndexScan(tab->ref.key, 1);
2625
 
 
2626
 
    if (error != 0)
2627
 
    {
2628
 
      error= table->report_error(error);
2629
 
      return(error != 0);
2630
 
    }
2631
 
  }
2632
 
  error= table->cursor->index_read_map(table->record[0],
 
2558
  if (!table->file->inited)
 
2559
    table->file->ha_index_init(tab->ref.key, 1);
 
2560
  error= table->file->index_read_map(table->record[0],
2633
2561
                                     tab->ref.key_buff,
2634
2562
                                     make_prev_keypart_map(tab->ref.key_parts),
2635
2563
                                     HA_READ_KEY_EXACT);
2653
2581
            ((Item_in_subselect *) item)->value= 1;
2654
2582
          break;
2655
2583
        }
2656
 
        error= table->cursor->index_next_same(table->record[0],
 
2584
        error= table->file->index_next_same(table->record[0],
2657
2585
                                            tab->ref.key_buff,
2658
2586
                                            tab->ref.key_length);
2659
2587
        if (error && error != HA_ERR_END_OF_FILE)
2678
2606
}
2679
2607
 
2680
2608
 
2681
 
uint32_t subselect_single_select_engine::cols()
 
2609
uint subselect_single_select_engine::cols()
2682
2610
{
2683
2611
  return select_lex->item_list.elements;
2684
2612
}
2685
2613
 
2686
2614
 
2687
 
uint32_t subselect_union_engine::cols()
 
2615
uint subselect_union_engine::cols()
2688
2616
{
2689
2617
  return unit->types.elements;
2690
2618
}
2691
2619
 
2692
2620
 
2693
 
bool subselect_single_select_engine::uncacheable()
2694
 
{
2695
 
  return select_lex->uncacheable.any();
2696
 
}
2697
 
 
2698
 
 
2699
 
bool subselect_single_select_engine::uncacheable(uint32_t bit_pos)
2700
 
{
2701
 
  return select_lex->uncacheable.test(bit_pos);
2702
 
}
2703
 
 
2704
 
 
2705
 
bool subselect_union_engine::uncacheable()
2706
 
{
2707
 
  return unit->uncacheable.any();
2708
 
}
2709
 
 
2710
 
 
2711
 
bool subselect_union_engine::uncacheable(uint32_t bit_pos)
2712
 
{
2713
 
  return unit->uncacheable.test(bit_pos);
 
2621
uint8_t subselect_single_select_engine::uncacheable()
 
2622
{
 
2623
  return select_lex->uncacheable;
 
2624
}
 
2625
 
 
2626
 
 
2627
uint8_t subselect_union_engine::uncacheable()
 
2628
{
 
2629
  return unit->uncacheable;
2714
2630
}
2715
2631
 
2716
2632
 
2761
2677
void subselect_single_select_engine::print(String *str,
2762
2678
                                           enum_query_type query_type)
2763
2679
{
2764
 
  select_lex->print(session, str, query_type);
 
2680
  select_lex->print(thd, str, query_type);
2765
2681
}
2766
2682
 
2767
2683
 
2774
2690
void subselect_uniquesubquery_engine::print(String *str,
2775
2691
                                            enum_query_type query_type)
2776
2692
{
2777
 
  char *table_name= const_cast<char *>(tab->table->getShare()->getTableName());
 
2693
  char *table_name= tab->table->s->table_name.str;
2778
2694
  str->append(STRING_WITH_LEN("<primary_index_lookup>("));
2779
2695
  tab->ref.items[0]->print(str, query_type);
2780
2696
  str->append(STRING_WITH_LEN(" in "));
2781
 
  if (tab->table->getShare()->isTemporaryCategory())
 
2697
  if (tab->table->s->table_category == TABLE_CATEGORY_TEMPORARY)
2782
2698
  {
2783
2699
    /*
2784
2700
      Temporary tables' names change across runs, so they can't be used for
2787
2703
    str->append(STRING_WITH_LEN("<temporary table>"));
2788
2704
  }
2789
2705
  else
2790
 
    str->append(table_name, tab->table->getShare()->getTableNameSize());
2791
 
  KeyInfo *key_info= tab->table->key_info+ tab->ref.key;
 
2706
    str->append(table_name, tab->table->s->table_name.length);
 
2707
  KEY *key_info= tab->table->key_info+ tab->ref.key;
2792
2708
  str->append(STRING_WITH_LEN(" on "));
2793
2709
  str->append(key_info->name);
2794
2710
  if (cond)
2808
2724
{
2809
2725
  KEY *key_info= tab->table->key_info + tab->ref.key;
2810
2726
  str->append(STRING_WITH_LEN("<primary_index_lookup>("));
2811
 
  for (uint32_t i= 0; i < key_info->key_parts; i++)
 
2727
  for (uint i= 0; i < key_info->key_parts; i++)
2812
2728
    tab->ref.items[i]->print(str);
2813
2729
  str->append(STRING_WITH_LEN(" in "));
2814
 
  str->append(tab->table->getShare()->getTableName(), tab->table->getShare()->getTableNameSize());
 
2730
  str->append(tab->table->s->table_name.str, tab->table->s->table_name.length);
2815
2731
  str->append(STRING_WITH_LEN(" on "));
2816
2732
  str->append(key_info->name);
2817
2733
  if (cond)
2829
2745
  str->append(STRING_WITH_LEN("<index_lookup>("));
2830
2746
  tab->ref.items[0]->print(str, query_type);
2831
2747
  str->append(STRING_WITH_LEN(" in "));
2832
 
  str->append(tab->table->getShare()->getTableName(), tab->table->getShare()->getTableNameSize());
2833
 
  KeyInfo *key_info= tab->table->key_info+ tab->ref.key;
 
2748
  str->append(tab->table->s->table_name.str, tab->table->s->table_name.length);
 
2749
  KEY *key_info= tab->table->key_info+ tab->ref.key;
2834
2750
  str->append(STRING_WITH_LEN(" on "));
2835
2751
  str->append(key_info->name);
2836
2752
  if (check_null)
2903
2819
    true  error
2904
2820
*/
2905
2821
 
2906
 
bool subselect_uniquesubquery_engine::change_result(Item_subselect *,
2907
 
                                                    select_result_interceptor *)
 
2822
bool subselect_uniquesubquery_engine::change_result(Item_subselect *si __attribute__((unused)),
 
2823
                                                    select_result_interceptor *res __attribute__((unused)))
2908
2824
{
2909
2825
  assert(0);
2910
2826
  return true;
2951
2867
*/
2952
2868
bool subselect_union_engine::no_tables()
2953
2869
{
2954
 
  for (Select_Lex *sl= unit->first_select(); sl; sl= sl->next_select())
 
2870
  for (SELECT_LEX *sl= unit->first_select(); sl; sl= sl->next_select())
2955
2871
  {
2956
2872
    if (sl->table_list.elements)
2957
2873
      return false;
2990
2906
    temporary table has one hash index on all its columns.
2991
2907
  - Create a new result sink that sends the result stream of the subquery to
2992
2908
    the temporary table,
2993
 
  - Create and initialize a new JoinTable, and TABLE_REF objects to perform
 
2909
  - Create and initialize a new JOIN_TAB, and TABLE_REF objects to perform
2994
2910
    lookups into the indexed temporary table.
2995
2911
 
2996
2912
  @notice:
3007
2923
  select_union  *tmp_result_sink;
3008
2924
  /* The table into which the subquery is materialized. */
3009
2925
  Table         *tmp_table;
3010
 
  KeyInfo           *tmp_key; /* The only index on the temporary table. */
3011
 
  uint32_t          tmp_key_parts; /* Number of keyparts in tmp_key. */
 
2926
  KEY           *tmp_key; /* The only index on the temporary table. */
 
2927
  uint          tmp_key_parts; /* Number of keyparts in tmp_key. */
3012
2928
  Item_in_subselect *item_in= (Item_in_subselect *) item;
3013
2929
 
3014
2930
  /* 1. Create/initialize materialization related objects. */
3020
2936
  */
3021
2937
  if (!(tmp_result_sink= new select_union))
3022
2938
    return(true);
3023
 
 
3024
2939
  if (tmp_result_sink->create_result_table(
3025
 
                         session, tmp_columns, true,
3026
 
                         session->options | TMP_TABLE_ALL_COLUMNS,
3027
 
                         "materialized subselect"))
 
2940
                         thd, tmp_columns, true,
 
2941
                         thd->options | TMP_TABLE_ALL_COLUMNS,
 
2942
                         "materialized subselect", true))
3028
2943
    return(true);
3029
2944
 
3030
2945
  tmp_table= tmp_result_sink->table;
3038
2953
     table since it will not be used, and tell the caller we failed to
3039
2954
     initialize the engine.
3040
2955
  */
3041
 
  if (tmp_table->getShare()->sizeKeys() == 0)
 
2956
  if (tmp_table->s->keys == 0)
3042
2957
  {
3043
 
    assert(tmp_table->getShare()->db_type() == myisam_engine);
 
2958
    assert(tmp_table->s->db_type() == myisam_hton);
3044
2959
    assert(
3045
 
      tmp_table->getShare()->uniques ||
3046
 
      tmp_table->key_info->key_length >= tmp_table->cursor->getEngine()->max_key_length() ||
3047
 
      tmp_table->key_info->key_parts > tmp_table->cursor->getEngine()->max_key_parts());
3048
 
    tmp_table= NULL;
 
2960
      tmp_table->s->uniques ||
 
2961
      tmp_table->key_info->key_length >= tmp_table->file->max_key_length() ||
 
2962
      tmp_table->key_info->key_parts > tmp_table->file->max_key_parts());
 
2963
    tmp_table->free_tmp_table(thd);
3049
2964
    delete result;
3050
2965
    result= NULL;
3051
2966
    return(true);
3056
2971
    Make sure there is only one index on the temp table, and it doesn't have
3057
2972
    the extra key part created when s->uniques > 0.
3058
2973
  */
3059
 
  assert(tmp_table->getShare()->sizeKeys() == 1 && tmp_columns->elements == tmp_key_parts);
 
2974
  assert(tmp_table->s->keys == 1 && tmp_columns->elements == tmp_key_parts);
3060
2975
 
3061
2976
 
3062
2977
  /* 2. Create/initialize execution related objects. */
3063
2978
 
3064
2979
  /*
3065
 
    Create and initialize the JoinTable that represents an index lookup
 
2980
    Create and initialize the JOIN_TAB that represents an index lookup
3066
2981
    plan operator into the materialized subquery result. Notice that:
3067
 
    - this JoinTable has no corresponding JOIN (and doesn't need one), and
 
2982
    - this JOIN_TAB has no corresponding JOIN (and doesn't need one), and
3068
2983
    - here we initialize only those members that are used by
3069
2984
      subselect_uniquesubquery_engine, so these objects are incomplete.
3070
 
  */
3071
 
  if (!(tab= (JoinTable*) session->getMemRoot()->allocate(sizeof(JoinTable))))
 
2985
  */ 
 
2986
  if (!(tab= (JOIN_TAB*) thd->alloc(sizeof(JOIN_TAB))))
3072
2987
    return(true);
3073
 
  new (tab) JoinTable();
3074
2988
  tab->table= tmp_table;
3075
2989
  tab->ref.key= 0; /* The only temp table index. */
3076
2990
  tab->ref.key_length= tmp_key->key_length;
3077
2991
  if (!(tab->ref.key_buff=
3078
 
        (unsigned char*) session->calloc(ALIGN_SIZE(tmp_key->key_length) * 2)) ||
 
2992
        (uchar*) thd->calloc(ALIGN_SIZE(tmp_key->key_length) * 2)) ||
3079
2993
      !(tab->ref.key_copy=
3080
 
        (StoredKey**) session->getMemRoot()->allocate((sizeof(StoredKey*) *
 
2994
        (store_key**) thd->alloc((sizeof(store_key*) *
3081
2995
                                  (tmp_key_parts + 1)))) ||
3082
2996
      !(tab->ref.items=
3083
 
        (Item**) session->getMemRoot()->allocate(sizeof(Item*) * tmp_key_parts)))
 
2997
        (Item**) thd->alloc(sizeof(Item*) * tmp_key_parts)))
3084
2998
    return(true);
3085
2999
 
3086
 
  KeyPartInfo *cur_key_part= tmp_key->key_part;
3087
 
  StoredKey **ref_key= tab->ref.key_copy;
3088
 
  unsigned char *cur_ref_buff= tab->ref.key_buff;
3089
 
 
3090
 
  for (uint32_t i= 0; i < tmp_key_parts; i++, cur_key_part++, ref_key++)
 
3000
  KEY_PART_INFO *cur_key_part= tmp_key->key_part;
 
3001
  store_key **ref_key= tab->ref.key_copy;
 
3002
  uchar *cur_ref_buff= tab->ref.key_buff;
 
3003
  
 
3004
  for (uint i= 0; i < tmp_key_parts; i++, cur_key_part++, ref_key++)
3091
3005
  {
3092
3006
    tab->ref.items[i]= item_in->left_expr->element_index(i);
3093
3007
    int null_count= test(cur_key_part->field->real_maybe_null());
3094
 
    *ref_key= new store_key_item(session, cur_key_part->field,
 
3008
    *ref_key= new store_key_item(thd, cur_key_part->field,
3095
3009
                                 /* TODO:
3096
3010
                                    the NULL byte is taken into account in
3097
3011
                                    cur_key_part->store_length, so instead of
3137
3051
{
3138
3052
  delete result;
3139
3053
  if (tab)
3140
 
  {
3141
 
    tab->table= NULL;
3142
 
  }
 
3054
    tab->table->free_tmp_table(thd);
3143
3055
}
3144
3056
 
3145
3057
 
3147
3059
  Cleanup performed after each PS execution.
3148
3060
 
3149
3061
  @detail
3150
 
  Called in the end of Join::prepare for PS from Item_subselect::cleanup.
 
3062
  Called in the end of JOIN::prepare for PS from Item_subselect::cleanup.
3151
3063
*/
3152
3064
 
3153
3065
void subselect_hash_sj_engine::cleanup()
3181
3093
  if (!is_materialized)
3182
3094
  {
3183
3095
    int res= 0;
3184
 
    Select_Lex *save_select= session->lex->current_select;
3185
 
    session->lex->current_select= materialize_engine->select_lex;
 
3096
    SELECT_LEX *save_select= thd->lex->current_select;
 
3097
    thd->lex->current_select= materialize_engine->select_lex;
3186
3098
    if ((res= materialize_join->optimize()))
3187
3099
      goto err;
3188
 
 
3189
 
    if (materialize_engine->save_join_if_explain())
3190
 
      goto err;
3191
 
 
3192
3100
    materialize_join->exec();
3193
 
    if ((res= test(materialize_join->error || session->is_fatal_error)))
 
3101
    if ((res= test(materialize_join->error || thd->is_fatal_error)))
3194
3102
      goto err;
3195
3103
 
3196
3104
    /*
3197
3105
      TODO:
3198
3106
      - Unlock all subquery tables as we don't need them. To implement this
3199
 
        we need to add new functionality to Join::join_free that can unlock
 
3107
        we need to add new functionality to JOIN::join_free that can unlock
3200
3108
        all tables in a subquery (and all its subqueries).
3201
3109
      - The temp table used for grouping in the subquery can be freed
3202
3110
        immediately after materialization (yet it's done together with
3209
3117
      statistics, then we test if the temporary table for the query result is
3210
3118
      empty.
3211
3119
    */
3212
 
    tab->table->cursor->info(HA_STATUS_VARIABLE);
3213
 
    if (!tab->table->cursor->stats.records)
 
3120
    tab->table->file->info(HA_STATUS_VARIABLE);
 
3121
    if (!tab->table->file->stats.records)
3214
3122
    {
3215
3123
      empty_result_set= true;
3216
3124
      item_in->value= false;
3223
3131
      tmp_param= NULL;
3224
3132
 
3225
3133
err:
3226
 
    session->lex->current_select= save_select;
 
3134
    thd->lex->current_select= save_select;
3227
3135
    if (res)
3228
3136
      return(res);
3229
3137
  }
3251
3159
           "<the access method for lookups is not yet created>"
3252
3160
         ));
3253
3161
}
3254
 
 
3255
 
} /* namespace drizzled */