← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/subselect.h

  • Committer: Brian Aker
  • Date: 2010-12-18 18:24:57 UTC
  • mfrom: (1999.6.3 trunk)
  • Revision ID: brian@tangent.org-20101218182457-yi1wd0so2hml1k1w
Merge in Lee's copyright header fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/subselect.h
1
 
/* Copyright (C) 2000 MySQL AB
2
 
 
3
 
   This program is free software; you can redistribute it and/or modify
4
 
   it under the terms of the GNU General Public License as published by
5
 
   the Free Software Foundation; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
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, Inc.
 
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
#ifndef DRIZZLED_ITEM_SUBSELECT_H
 
21
#define DRIZZLED_ITEM_SUBSELECT_H
15
22
 
16
23
/* subselect Item */
17
24
 
18
 
#ifdef USE_PRAGMA_INTERFACE
19
 
#pragma interface                       /* gcc class implementation */
20
 
#endif
21
 
 
22
 
class st_select_lex;
23
 
class st_select_lex_unit;
24
 
class JOIN;
 
25
 
 
26
#include "drizzled/comp_creator.h"
 
27
#include "drizzled/item/ref.h"
 
28
#include "drizzled/item/field.h"
 
29
#include "drizzled/item/bin_string.h"
 
30
#include "drizzled/util/test.h"
 
31
 
 
32
namespace drizzled
 
33
{
 
34
 
 
35
class Select_Lex;
 
36
class Select_Lex_Unit;
 
37
class Join;
25
38
class select_result_interceptor;
26
39
class subselect_engine;
27
40
class subselect_hash_sj_engine;
28
41
class Item_bool_func2;
29
42
class Cached_item;
 
43
class Item_in_optimizer;
 
44
class Item_func_not_all;
 
45
class Tmp_Table_Param;
 
46
 
30
47
 
31
48
/* base class for subselects */
32
49
 
35
52
  bool value_assigned; /* value already assigned to subselect */
36
53
public:
37
54
  /* thread handler, will be assigned in fix_fields only */
38
 
  THD *thd;
 
55
  Session *session;
39
56
  /* substitution instead of subselect in case of optimization */
40
57
  Item *substitution;
41
58
  /* unit of subquery */
42
 
public:
43
 
  st_select_lex_unit *unit;
 
59
  Select_Lex_Unit *unit;
44
60
protected:
45
61
  /* engine that perform execution of subselect (single select or union) */
46
62
  subselect_engine *engine;
49
65
  /* cache of used external tables */
50
66
  table_map used_tables_cache;
51
67
  /* allowed number of columns (1 for single value subqueries) */
52
 
  uint max_columns;
 
68
  uint32_t max_columns;
53
69
  /* where subquery is placed */
54
70
  enum_parsing_place parsing_place;
55
71
  /* work with 'substitution' */
64
80
  bool changed;
65
81
 
66
82
  /* TRUE <=> The underlying SELECT is correlated w.r.t some ancestor select */
67
 
  bool is_correlated; 
 
83
  bool is_correlated;
68
84
 
69
85
  enum trans_res {RES_OK, RES_REDUCE, RES_ERROR};
70
86
  enum subs_type {UNKNOWN_SUBS, SINGLEROW_SUBS,
79
95
    pointer in constructor initialization list, but we need to pass a pointer
80
96
    to subselect Item class to select_result_interceptor's constructor.
81
97
  */
82
 
  virtual void init (st_select_lex *select_lex,
 
98
  virtual void init (Select_Lex *select_lex,
83
99
                     select_result_interceptor *result);
84
100
 
85
101
  ~Item_subselect();
88
104
  {
89
105
    null_value= 1;
90
106
  }
91
 
  virtual trans_res select_transformer(JOIN *join);
 
107
  virtual trans_res select_transformer(Join *join);
92
108
  bool assigned() { return value_assigned; }
93
109
  void assigned(bool a) { value_assigned= a; }
94
110
  enum Type type() const;
97
113
    update_null_value();
98
114
    return null_value;
99
115
  }
100
 
  bool fix_fields(THD *thd, Item **ref);
 
116
  bool fix_fields(Session *session, Item **ref);
101
117
  virtual bool exec();
102
118
  virtual void fix_length_and_dec();
103
119
  table_map used_tables() const;
105
121
  bool const_item() const;
106
122
  inline table_map get_used_tables_cache() { return used_tables_cache; }
107
123
  inline bool get_const_item_cache() { return const_item_cache; }
108
 
  Item *get_tmp_table_item(THD *thd);
 
124
  Item *get_tmp_table_item(Session *session);
109
125
  void update_used_tables();
110
126
  virtual void print(String *str, enum_query_type query_type);
111
127
  virtual bool have_guarded_conds() { return false; }
129
145
  */
130
146
  virtual void reset_value_registration() {}
131
147
  enum_parsing_place place() { return parsing_place; }
132
 
  bool walk(Item_processor processor, bool walk_subquery, uchar *arg);
 
148
  bool walk(Item_processor processor, bool walk_subquery, unsigned char *arg);
133
149
 
134
150
  /**
135
 
    Get the SELECT_LEX structure associated with this Item.
136
 
    @return the SELECT_LEX structure associated with this Item
 
151
    Get the Select_Lex structure associated with this Item.
 
152
    @return the Select_Lex structure associated with this Item
137
153
  */
138
 
  st_select_lex* get_select_lex();
 
154
  Select_Lex* get_select_lex();
139
155
 
140
156
  friend class select_result_interceptor;
141
157
  friend class Item_in_optimizer;
142
 
  friend bool Item_field::fix_fields(THD *, Item **);
143
 
  friend int  Item_field::fix_outer_field(THD *, Field **, Item **);
144
 
  friend bool Item_ref::fix_fields(THD *, Item **);
145
 
  friend void mark_select_range_as_dependent(THD*,
146
 
                                             st_select_lex*, st_select_lex*,
 
158
  friend bool Item_field::fix_fields(Session *, Item **);
 
159
  friend int  Item_field::fix_outer_field(Session *, Field **, Item **);
 
160
  friend bool Item_ref::fix_fields(Session *, Item **);
 
161
  friend void mark_select_range_as_dependent(Session*,
 
162
                                             Select_Lex*, Select_Lex*,
147
163
                                             Field*, Item*, Item_ident*);
148
164
};
149
165
 
155
171
protected:
156
172
  Item_cache *value, **row;
157
173
public:
158
 
  Item_singlerow_subselect(st_select_lex *select_lex);
 
174
  Item_singlerow_subselect(Select_Lex *select_lex);
159
175
  Item_singlerow_subselect() :Item_subselect(), value(0), row (0) {}
160
176
 
161
177
  void cleanup();
162
178
  subs_type substype() { return SINGLEROW_SUBS; }
163
179
 
164
180
  void reset();
165
 
  trans_res select_transformer(JOIN *join);
166
 
  void store(uint i, Item* item);
 
181
  trans_res select_transformer(Join *join);
 
182
  void store(uint32_t i, Item* item);
167
183
  double val_real();
168
184
  int64_t val_int ();
169
185
  String *val_str (String *);
173
189
  enum_field_types field_type() const;
174
190
  void fix_length_and_dec();
175
191
 
176
 
  uint cols();
177
 
  Item* element_index(uint i) { return my_reinterpret_cast(Item*)(row[i]); }
178
 
  Item** addr(uint i) { return (Item**)row + i; }
179
 
  bool check_cols(uint c);
 
192
  uint32_t cols();
 
193
  Item* element_index(uint32_t i) { return reinterpret_cast<Item*>(row[i]); }
 
194
  Item** addr(uint32_t i) { return (Item**)row + i; }
 
195
  bool check_cols(uint32_t c);
180
196
  bool null_inside();
181
197
  void bring_value();
182
198
 
186
202
    The only caller of this method is handle_sql2003_note184_exception(),
187
203
    see the code there for more details.
188
204
    Note that this method breaks the object internal integrity, by
189
 
    removing it's association with the corresponding SELECT_LEX,
 
205
    removing it's association with the corresponding Select_Lex,
190
206
    making this object orphan from the parse tree.
191
207
    No other method, beside the destructor, should be called on this
192
208
    object, as it is now invalid.
193
 
    @return the SELECT_LEX structure that was given in the constructor.
 
209
    @return the Select_Lex structure that was given in the constructor.
194
210
  */
195
 
  st_select_lex* invalidate_and_restore_select_lex();
 
211
  Select_Lex* invalidate_and_restore_select_lex();
196
212
 
197
213
  friend class select_singlerow_subselect;
198
214
};
205
221
  bool max;
206
222
  bool was_values;  // Set if we have found at least one row
207
223
public:
208
 
  Item_maxmin_subselect(THD *thd, Item_subselect *parent,
209
 
                        st_select_lex *select_lex, bool max);
 
224
  Item_maxmin_subselect(Session *session, Item_subselect *parent,
 
225
                        Select_Lex *select_lex, bool max);
210
226
  virtual void print(String *str, enum_query_type query_type);
211
227
  void cleanup();
212
228
  bool any_value() { return was_values; }
222
238
  bool value; /* value of this item (boolean: exists/not-exists) */
223
239
 
224
240
public:
225
 
  Item_exists_subselect(st_select_lex *select_lex);
 
241
  Item_exists_subselect(Select_Lex *select_lex);
226
242
  Item_exists_subselect(): Item_subselect() {}
227
243
 
228
244
  subs_type substype() { return EXISTS_SUBS; }
229
 
  void reset() 
 
245
  void reset()
230
246
  {
231
247
    value= 0;
232
248
  }
251
267
  "left_expr IN (SELECT ...)".
252
268
 
253
269
  @detail
254
 
  This class has: 
 
270
  This class has:
255
271
   - A "subquery execution engine" (as a subclass of Item_subselect) that allows
256
272
     it to evaluate subqueries. (and this class participates in execution by
257
273
     having was_null variable where part of execution result is stored.
285
301
public:
286
302
  /* Used to trigger on/off conditions that were pushed down to subselect */
287
303
  bool *pushed_cond_guards;
288
 
  
 
304
 
289
305
  /* Priority of this predicate in the convert-to-semi-join-nest process. */
290
306
  int sj_convert_priority;
291
307
 
292
 
  /* 
 
308
  /*
293
309
    Location of the subquery predicate. It is either
294
310
     - pointer to join nest if the subquery predicate is in the ON expression
295
 
     - (TABLE_LIST*)1 if the predicate is in the WHERE.
 
311
     - (TableList*)1 if the predicate is in the WHERE.
296
312
  */
297
 
  TABLE_LIST *expr_join_nest;
 
313
  TableList *expr_join_nest;
298
314
 
299
315
  /* The method chosen to execute the IN predicate.  */
300
316
  enum enum_exec_method {
309
325
  {
310
326
    return pushed_cond_guards ? pushed_cond_guards + i : NULL;
311
327
  }
312
 
  void set_cond_guard_var(int i, bool v) 
313
 
  { 
 
328
  void set_cond_guard_var(int i, bool v)
 
329
  {
314
330
    if ( pushed_cond_guards)
315
331
      pushed_cond_guards[i]= v;
316
332
  }
318
334
 
319
335
  Item_func_not_all *upper_item; // point on NOT/NOP before ALL/SOME subquery
320
336
 
321
 
  Item_in_subselect(Item * left_expr, st_select_lex *select_lex);
 
337
  Item_in_subselect(Item * left_expr, Select_Lex *select_lex);
322
338
  Item_in_subselect()
323
 
    :Item_exists_subselect(), left_expr_cache(0), first_execution(true),
324
 
    optimizer(0), abort_on_null(0), pushed_cond_guards(NULL),
325
 
    exec_method(NOT_TRANSFORMED), upper_item(0)
 
339
    :
 
340
      Item_exists_subselect(),
 
341
      left_expr(NULL),
 
342
      left_expr_cache(NULL),
 
343
      first_execution(true),
 
344
      optimizer(NULL),
 
345
      abort_on_null(false),
 
346
      pushed_cond_guards(NULL),
 
347
      sj_convert_priority(0),
 
348
      expr_join_nest(NULL),
 
349
      exec_method(NOT_TRANSFORMED),
 
350
      upper_item(NULL)
326
351
  {}
327
352
  void cleanup();
328
353
  subs_type substype() { return IN_SUBS; }
329
 
  void reset() 
 
354
  void reset()
330
355
  {
331
356
    value= 0;
332
357
    null_value= 0;
333
358
    was_null= 0;
334
359
  }
335
 
  trans_res select_transformer(JOIN *join);
336
 
  trans_res select_in_like_transformer(JOIN *join, Comp_creator *func);
337
 
  trans_res single_value_transformer(JOIN *join, Comp_creator *func);
338
 
  trans_res row_value_transformer(JOIN * join);
339
 
  trans_res single_value_in_to_exists_transformer(JOIN * join,
340
 
                                                  Comp_creator *func);
341
 
  trans_res row_value_in_to_exists_transformer(JOIN * join);
 
360
  trans_res select_transformer(Join *join);
 
361
  trans_res select_in_like_transformer(Join *join, const Comp_creator *func);
 
362
  trans_res single_value_transformer(Join *join, const Comp_creator *func);
 
363
  trans_res row_value_transformer(Join * join);
 
364
  trans_res single_value_in_to_exists_transformer(Join * join,
 
365
                                                  const Comp_creator *func);
 
366
  trans_res row_value_in_to_exists_transformer(Join * join);
342
367
  virtual bool exec();
343
368
  int64_t val_int();
344
369
  double val_real();
348
373
  bool val_bool();
349
374
  void top_level_item() { abort_on_null=1; }
350
375
  inline bool is_top_level_item() { return abort_on_null; }
351
 
  bool test_limit(st_select_lex_unit *unit);
 
376
  bool test_limit(Select_Lex_Unit *unit);
352
377
  virtual void print(String *str, enum_query_type query_type);
353
 
  bool fix_fields(THD *thd, Item **ref);
 
378
  bool fix_fields(Session *session, Item **ref);
354
379
  bool setup_engine();
355
380
  bool init_left_expr_cache();
356
 
  bool is_expensive_processor(uchar *arg);
 
381
  bool is_expensive_processor(unsigned char *arg);
357
382
 
358
383
  friend class Item_ref_null_helper;
359
384
  friend class Item_is_not_null_test;
372
397
  bool all;
373
398
 
374
399
  Item_allany_subselect(Item * left_expr, chooser_compare_func_creator fc,
375
 
                        st_select_lex *select_lex, bool all);
 
400
                        Select_Lex *select_lex, bool all);
376
401
 
377
402
  // only ALL subquery has upper not
378
403
  subs_type substype() { return all?ALL_SUBS:ANY_SUBS; }
379
 
  trans_res select_transformer(JOIN *join);
 
404
  trans_res select_transformer(Join *join);
380
405
  virtual void print(String *str, enum_query_type query_type);
381
406
};
382
407
 
383
408
 
384
 
class subselect_engine: public Sql_alloc
 
409
class subselect_engine: public memory::SqlAlloc
385
410
{
386
411
protected:
387
412
  select_result_interceptor *result; /* results storage class */
388
 
  THD *thd; /* pointer to current THD */
 
413
  Session *session; /* pointer to current Session */
389
414
  Item_subselect *item; /* item, that use this engine */
390
415
  enum Item_result res_type; /* type of results */
391
416
  enum_field_types res_field_type; /* column type of the results */
397
422
                         INDEXSUBQUERY_ENGINE, HASH_SJ_ENGINE};
398
423
 
399
424
  subselect_engine(Item_subselect *si, select_result_interceptor *res)
400
 
    :thd(0)
 
425
    :session(NULL)
401
426
  {
402
427
    result= res;
403
428
    item= si;
405
430
    res_field_type= DRIZZLE_TYPE_VARCHAR;
406
431
    maybe_null= 0;
407
432
  }
408
 
  virtual ~subselect_engine() {}; // to satisfy compiler
 
433
  virtual ~subselect_engine() {} // to satisfy compiler
409
434
  virtual void cleanup()= 0;
410
435
 
411
436
  /*
412
 
    Also sets "thd" for subselect_engine::result.
 
437
    Also sets "session" for subselect_engine::result.
413
438
    Should be called before prepare().
414
439
  */
415
 
  void set_thd(THD *thd_arg);
416
 
  THD * get_thd() { return thd; }
 
440
  void set_session(Session *session_arg);
 
441
  Session * get_session() { return session; }
417
442
  virtual int prepare()= 0;
418
443
  virtual void fix_length_and_dec(Item_cache** row)= 0;
419
444
  /*
428
453
      stored somewhere by the exec() method itself.
429
454
 
430
455
      A required side effect: If at least one pushed-down predicate is
431
 
      disabled, subselect_engine->no_rows() must return correct result after 
 
456
      disabled, subselect_engine->no_rows() must return correct result after
432
457
      the exec() call.
433
458
 
434
459
    RETURN
437
462
          caller should call exec() again for the new engine.
438
463
  */
439
464
  virtual int exec()= 0;
440
 
  virtual uint cols()= 0; /* return number of columns in select */
441
 
  virtual uint8_t uncacheable()= 0; /* query is uncacheable */
 
465
  virtual uint32_t cols()= 0; /* return number of columns in select */
 
466
  virtual bool uncacheable()= 0; /* query is uncacheable */
 
467
  virtual bool uncacheable(uint32_t bit_pos)= 0; /* query is uncacheable */
442
468
  enum Item_result type() { return res_type; }
443
469
  enum_field_types field_type() { return res_field_type; }
444
470
  virtual void exclude()= 0;
445
 
  virtual bool may_be_null() { return maybe_null; };
 
471
  virtual bool may_be_null() { return maybe_null; }
446
472
  virtual table_map upper_select_const_tables()= 0;
447
 
  static table_map calc_const_tables(TABLE_LIST *);
 
473
  static table_map calc_const_tables(TableList *);
448
474
  virtual void print(String *str, enum_query_type query_type)= 0;
449
475
  virtual bool change_result(Item_subselect *si,
450
476
                             select_result_interceptor *result)= 0;
464
490
  bool prepared; /* simple subselect is prepared */
465
491
  bool optimized; /* simple subselect is optimized */
466
492
  bool executed; /* simple subselect is executed */
467
 
  st_select_lex *select_lex; /* corresponding select_lex */
468
 
  JOIN * join; /* corresponding JOIN structure */
 
493
  Select_Lex *select_lex; /* corresponding select_lex */
 
494
  Join * join; /* corresponding JOIN structure */
469
495
public:
470
 
  subselect_single_select_engine(st_select_lex *select,
 
496
  subselect_single_select_engine(Select_Lex *select,
471
497
                                 select_result_interceptor *result,
472
498
                                 Item_subselect *item);
473
499
  void cleanup();
474
500
  int prepare();
475
501
  void fix_length_and_dec(Item_cache** row);
476
502
  int exec();
477
 
  uint cols();
478
 
  uint8_t uncacheable();
 
503
  uint32_t cols();
 
504
  bool uncacheable();
 
505
  bool uncacheable(uint32_t bit_pos);
479
506
  void exclude();
480
507
  table_map upper_select_const_tables();
481
508
  virtual void print (String *str, enum_query_type query_type);
493
520
 
494
521
class subselect_union_engine: public subselect_engine
495
522
{
496
 
  st_select_lex_unit *unit;  /* corresponding unit structure */
 
523
  Select_Lex_Unit *unit;  /* corresponding unit structure */
497
524
public:
498
 
  subselect_union_engine(st_select_lex_unit *u,
 
525
  subselect_union_engine(Select_Lex_Unit *u,
499
526
                         select_result_interceptor *result,
500
527
                         Item_subselect *item);
501
528
  void cleanup();
502
529
  int prepare();
503
530
  void fix_length_and_dec(Item_cache** row);
504
531
  int exec();
505
 
  uint cols();
506
 
  uint8_t uncacheable();
 
532
  uint32_t cols();
 
533
  bool uncacheable();
 
534
  bool uncacheable(uint32_t bit_pos);
507
535
  void exclude();
508
536
  table_map upper_select_const_tables();
509
537
  virtual void print (String *str, enum_query_type query_type);
515
543
};
516
544
 
517
545
 
518
 
struct st_join_table;
 
546
class JoinTable;
519
547
 
520
548
 
521
549
/*
523
551
  lookup in a unique index.
524
552
 
525
553
  This engine is used to resolve subqueries in forms
526
 
  
527
 
    outer_expr IN (SELECT tbl.unique_key FROM tbl WHERE subq_where) 
528
 
    
 
554
 
 
555
    outer_expr IN (SELECT tbl.unique_key FROM tbl WHERE subq_where)
 
556
 
529
557
  or, tuple-based:
530
 
  
 
558
 
531
559
    (oe1, .. oeN) IN (SELECT uniq_key_part1, ... uniq_key_partK
532
 
                      FROM tbl WHERE subqwhere) 
533
 
  
 
560
                      FROM tbl WHERE subqwhere)
 
561
 
534
562
  i.e. the subquery is a single table SELECT without GROUP BY, aggregate
535
563
  functions, etc.
536
564
*/
538
566
class subselect_uniquesubquery_engine: public subselect_engine
539
567
{
540
568
protected:
541
 
  st_join_table *tab;
 
569
  JoinTable *tab;
542
570
  Item *cond; /* The WHERE condition of subselect */
543
 
  /* 
 
571
  /*
544
572
    TRUE<=> last execution produced empty set. Valid only when left
545
573
    expression is NULL.
546
574
  */
548
576
  bool null_keypart; /* TRUE <=> constructed search tuple has a NULL */
549
577
public:
550
578
 
551
 
  // constructor can assign THD because it will be called after JOIN::prepare
552
 
  subselect_uniquesubquery_engine(THD *thd_arg, st_join_table *tab_arg,
 
579
  // constructor can assign Session because it will be called after Join::prepare
 
580
  subselect_uniquesubquery_engine(Session *session_arg, JoinTable *tab_arg,
553
581
                                  Item_subselect *subs, Item *where)
554
582
    :subselect_engine(subs, 0), tab(tab_arg), cond(where)
555
583
  {
556
 
    set_thd(thd_arg);
 
584
    set_session(session_arg);
557
585
  }
558
586
  void cleanup();
559
587
  int prepare();
560
588
  void fix_length_and_dec(Item_cache** row);
561
589
  int exec();
562
 
  uint cols() { return 1; }
563
 
  uint8_t uncacheable() { return UNCACHEABLE_DEPENDENT; }
 
590
  uint32_t cols() { return 1; }
 
591
  bool uncacheable() { return true; }
 
592
  bool uncacheable(uint32_t) { return true; }
564
593
  void exclude();
565
594
  table_map upper_select_const_tables() { return 0; }
566
595
  virtual void print (String *str, enum_query_type query_type);
577
606
{
578
607
  /* FALSE for 'ref', TRUE for 'ref-or-null'. */
579
608
  bool check_null;
580
 
  /* 
 
609
  /*
581
610
    The "having" clause. This clause (further reffered to as "artificial
582
 
    having") was inserted by subquery transformation code. It contains 
583
 
    Item(s) that have a side-effect: they record whether the subquery has 
 
611
    having") was inserted by subquery transformation code. It contains
 
612
    Item(s) that have a side-effect: they record whether the subquery has
584
613
    produced a row with NULL certain components. We need to use it for cases
585
614
    like
586
615
      (oe1, oe2) IN (SELECT t.key, t.no_key FROM t1)
587
616
    where we do index lookup on t.key=oe1 but need also to check if there
588
617
    was a row such that t.no_key IS NULL.
589
 
    
 
618
 
590
619
    NOTE: This is currently here and not in the uniquesubquery_engine. Ideally
591
620
    it should have been in uniquesubquery_engine in order to allow execution of
592
621
    subqueries like
593
 
    
 
622
 
594
623
      (oe1, oe2) IN (SELECT primary_key, non_key_maybe_null_field FROM tbl)
595
624
 
596
625
    We could use uniquesubquery_engine for the first component and let
603
632
    The above example subquery is handled as a full-blown SELECT with eq_ref
604
633
    access to one table.
605
634
 
606
 
    Due to this limitation, the "artificial having" currently needs to be 
 
635
    Due to this limitation, the "artificial having" currently needs to be
607
636
    checked by only in indexsubquery_engine.
608
637
  */
609
638
  Item *having;
610
639
public:
611
640
 
612
 
  // constructor can assign THD because it will be called after JOIN::prepare
613
 
  subselect_indexsubquery_engine(THD *thd_arg, st_join_table *tab_arg,
 
641
  // constructor can assign Session because it will be called after Join::prepare
 
642
  subselect_indexsubquery_engine(Session *session_arg, JoinTable *tab_arg,
614
643
                                 Item_subselect *subs, Item *where,
615
644
                                 Item *having_arg, bool chk_null)
616
 
    :subselect_uniquesubquery_engine(thd_arg, tab_arg, subs, where),
 
645
    :subselect_uniquesubquery_engine(session_arg, tab_arg, subs, where),
617
646
     check_null(chk_null),
618
647
     having(having_arg)
619
648
  {}
657
686
    QEP to execute the subquery and materialize its result into a
658
687
    temporary table. Created during the first call to exec().
659
688
  */
660
 
  JOIN *materialize_join;
 
689
  Join *materialize_join;
661
690
  /* Temp table context of the outer select's JOIN. */
662
 
  TMP_TABLE_PARAM *tmp_param;
 
691
  Tmp_Table_Param *tmp_param;
663
692
 
664
693
public:
665
 
  subselect_hash_sj_engine(THD *thd, Item_subselect *in_predicate,
 
694
  subselect_hash_sj_engine(Session *session_in, Item_subselect *in_predicate,
666
695
                               subselect_single_select_engine *old_engine)
667
 
    :subselect_uniquesubquery_engine(thd, NULL, in_predicate, NULL),
 
696
    :subselect_uniquesubquery_engine(session_in, NULL, in_predicate, NULL),
668
697
    is_materialized(false), materialize_engine(old_engine),
669
698
    materialize_join(NULL), tmp_param(NULL)
670
699
  {}
676
705
  int prepare() { return 0; }
677
706
  int exec();
678
707
  virtual void print (String *str, enum_query_type query_type);
679
 
  uint cols()
 
708
  uint32_t cols()
680
709
  {
681
710
    return materialize_engine->cols();
682
711
  }
683
712
  virtual enum_engine_type engine_type() { return HASH_SJ_ENGINE; }
684
713
};
 
714
 
 
715
} /* namespace drizzled */
 
716
 
 
717
#endif /* DRIZZLED_ITEM_SUBSELECT_H */