← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/sql_select.h

Removed reference to aio.h - we don't reference its use anywhere.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/sql_select.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008-2009 Sun Microsystems
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
19
 
 
20
 
#ifndef DRIZZLED_SQL_SELECT_H
21
 
#define DRIZZLED_SQL_SELECT_H
22
 
 
23
 
#include "drizzled/cached_item.h"
24
 
#include "drizzled/session.h"
25
 
#include "drizzled/field/varstring.h"
26
 
#include "drizzled/item/null.h"
27
 
#include <drizzled/enum_nested_loop_state.h>
28
 
#include "drizzled/optimizer/position.h"
29
 
#include "drizzled/optimizer/sargable_param.h"
30
 
#include "drizzled/optimizer/key_use.h"
31
 
#include "drizzled/join_cache.h"
32
 
#include "drizzled/join_table.h"
33
 
 
34
 
#include <vector>
35
 
 
36
 
namespace drizzled
37
 
{
38
 
 
39
 
class select_result;
 
1
/* Copyright (C) 2000-2006 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
40
16
 
41
17
/**
42
 
 * @file API and Classes to use when handling where clause
43
 
 */
44
 
 
45
 
/* PREV_BITS only used in sql_select.cc */
46
 
#define PREV_BITS(type,A)       ((type) (((type) 1 << (A)) -1))
 
18
  @file
 
19
 
 
20
  @brief
 
21
  classes to use when handling where clause
 
22
*/
 
23
 
 
24
#ifdef USE_PRAGMA_INTERFACE
 
25
#pragma interface                       /* gcc class implementation */
 
26
#endif
 
27
 
 
28
#include <myisam.h>
47
29
 
48
30
/* Values in optimize */
49
31
#define KEY_OPTIMIZE_EXISTS             1
50
32
#define KEY_OPTIMIZE_REF_OR_NULL        2
51
33
 
52
 
class Join;
53
 
 
54
 
enum_nested_loop_state sub_select_cache(Join *join, JoinTable *join_tab, bool end_of_records);
55
 
enum_nested_loop_state sub_select(Join *join,JoinTable *join_tab, bool end_of_records);
56
 
enum_nested_loop_state end_send_group(Join *join, JoinTable *join_tab, bool end_of_records);
57
 
enum_nested_loop_state end_write_group(Join *join, JoinTable *join_tab, bool end_of_records);
 
34
typedef struct keyuse_t {
 
35
  TABLE *table;
 
36
  Item  *val;                           /**< or value if no field */
 
37
  table_map used_tables;
 
38
  uint  key, keypart;
 
39
  uint optimize; // 0, or KEY_OPTIMIZE_*
 
40
  key_part_map keypart_map;
 
41
  ha_rows      ref_table_rows;
 
42
  /**
 
43
    If true, the comparison this value was created from will not be
 
44
    satisfied if val has NULL 'value'.
 
45
  */
 
46
  bool null_rejecting;
 
47
  /*
 
48
    !NULL - This KEYUSE was created from an equality that was wrapped into
 
49
            an Item_func_trig_cond. This means the equality (and validity of 
 
50
            this KEYUSE element) can be turned on and off. The on/off state 
 
51
            is indicted by the pointed value:
 
52
              *cond_guard == TRUE <=> equality condition is on
 
53
              *cond_guard == FALSE <=> equality condition is off
 
54
 
 
55
    NULL  - Otherwise (the source equality can't be turned off)
 
56
  */
 
57
  bool *cond_guard;
 
58
  /*
 
59
     0..64    <=> This was created from semi-join IN-equality # sj_pred_no.
 
60
     MAX_UINT  Otherwise
 
61
  */
 
62
  uint         sj_pred_no;
 
63
} KEYUSE;
 
64
 
 
65
class store_key;
 
66
 
 
67
typedef struct st_table_ref
 
68
{
 
69
  bool          key_err;
 
70
  uint          key_parts;                ///< num of ...
 
71
  uint          key_length;               ///< length of key_buff
 
72
  int           key;                      ///< key no
 
73
  uchar         *key_buff;                ///< value to look for with key
 
74
  uchar         *key_buff2;               ///< key_buff+key_length
 
75
  store_key     **key_copy;               //
 
76
  Item          **items;                  ///< val()'s for each keypart
 
77
  /*  
 
78
    Array of pointers to trigger variables. Some/all of the pointers may be
 
79
    NULL.  The ref access can be used iff
 
80
    
 
81
      for each used key part i, (!cond_guards[i] || *cond_guards[i]) 
 
82
 
 
83
    This array is used by subquery code. The subquery code may inject
 
84
    triggered conditions, i.e. conditions that can be 'switched off'. A ref 
 
85
    access created from such condition is not valid when at least one of the 
 
86
    underlying conditions is switched off (see subquery code for more details)
 
87
  */
 
88
  bool          **cond_guards;
 
89
  /**
 
90
    (null_rejecting & (1<<i)) means the condition is '=' and no matching
 
91
    rows will be produced if items[i] IS NULL (see add_not_null_conds())
 
92
  */
 
93
  key_part_map  null_rejecting;
 
94
  table_map     depend_map;               ///< Table depends on these tables.
 
95
  /* null byte position in the key_buf. Used for REF_OR_NULL optimization */
 
96
  uchar          *null_ref_key;
 
97
 
 
98
  /*
 
99
    TRUE <=> disable the "cache" as doing lookup with the same key value may
 
100
    produce different results (because of Index Condition Pushdown)
 
101
  */
 
102
  bool          disable_cache;
 
103
} TABLE_REF;
 
104
 
 
105
 
 
106
/**
 
107
  CACHE_FIELD and JOIN_CACHE is used on full join to cache records in outer
 
108
  table
 
109
*/
 
110
 
 
111
typedef struct st_cache_field {
 
112
  /* 
 
113
    Where source data is located (i.e. this points to somewhere in 
 
114
    tableX->record[0])
 
115
  */
 
116
  uchar *str;
 
117
  uint length; /* Length of data at *str, in bytes */
 
118
  uint blob_length; /* Valid IFF blob_field != 0 */
 
119
  Field_blob *blob_field;
 
120
  bool strip; /* TRUE <=> Strip endspaces ?? */
 
121
 
 
122
  TABLE *get_rowid; /* _ != NULL <=> */
 
123
} CACHE_FIELD;
 
124
 
 
125
 
 
126
typedef struct st_join_cache 
 
127
{
 
128
  uchar *buff;
 
129
  uchar *pos;    /* Start of free space in the buffer */
 
130
  uchar *end;
 
131
  uint records;  /* # of row cominations currently stored in the cache */
 
132
  uint record_nr;
 
133
  uint ptr_record; 
 
134
  /* 
 
135
    Number of fields (i.e. cache_field objects). Those correspond to table
 
136
    columns, and there are also special fields for
 
137
     - table's column null bits
 
138
     - table's null-complementation byte
 
139
     - [new] table's rowid.
 
140
  */
 
141
  uint fields; 
 
142
  uint length; 
 
143
  uint blobs;
 
144
  CACHE_FIELD *field;
 
145
  CACHE_FIELD **blob_ptr;
 
146
  SQL_SELECT *select;
 
147
} JOIN_CACHE;
 
148
 
 
149
 
 
150
/*
 
151
  The structs which holds the join connections and join states
 
152
*/
 
153
enum join_type { JT_UNKNOWN,JT_SYSTEM,JT_CONST,JT_EQ_REF,JT_REF,JT_MAYBE_REF,
 
154
                 JT_ALL, JT_RANGE, JT_NEXT, JT_REF_OR_NULL,
 
155
                 JT_UNIQUE_SUBQUERY, JT_INDEX_SUBQUERY, JT_INDEX_MERGE};
 
156
 
 
157
class JOIN;
 
158
 
 
159
enum enum_nested_loop_state
 
160
{
 
161
  NESTED_LOOP_KILLED= -2, NESTED_LOOP_ERROR= -1,
 
162
  NESTED_LOOP_OK= 0, NESTED_LOOP_NO_MORE_ROWS= 1,
 
163
  NESTED_LOOP_QUERY_LIMIT= 3, NESTED_LOOP_CURSOR_LIMIT= 4
 
164
};
 
165
 
 
166
 
 
167
/* Values for JOIN_TAB::packed_info */
 
168
#define TAB_INFO_HAVE_VALUE 1
 
169
#define TAB_INFO_USING_INDEX 2
 
170
#define TAB_INFO_USING_WHERE 4
 
171
#define TAB_INFO_FULL_SCAN_ON_NULL 8
 
172
 
 
173
class SJ_TMP_TABLE;
 
174
 
 
175
typedef enum_nested_loop_state
 
176
(*Next_select_func)(JOIN *, struct st_join_table *, bool);
 
177
typedef int (*Read_record_func)(struct st_join_table *tab);
 
178
Next_select_func setup_end_select_func(JOIN *join);
 
179
 
 
180
 
 
181
typedef struct st_join_table {
 
182
  st_join_table() {}                          /* Remove gcc warning */
 
183
  TABLE         *table;
 
184
  KEYUSE        *keyuse;                        /**< pointer to first used key */
 
185
  SQL_SELECT    *select;
 
186
  COND          *select_cond;
 
187
  QUICK_SELECT_I *quick;
 
188
  /* 
 
189
    The value of select_cond before we've attempted to do Index Condition
 
190
    Pushdown. We may need to restore everything back if we first choose one
 
191
    index but then reconsider (see test_if_skip_sort_order() for such
 
192
    scenarios).
 
193
    NULL means no index condition pushdown was performed.
 
194
  */
 
195
  Item          *pre_idx_push_select_cond;
 
196
  Item         **on_expr_ref;   /**< pointer to the associated on expression   */
 
197
  COND_EQUAL    *cond_equal;    /**< multiple equalities for the on expression */
 
198
  st_join_table *first_inner;   /**< first inner table for including outerjoin */
 
199
  bool           found;         /**< true after all matches or null complement */
 
200
  bool           not_null_compl;/**< true before null complement is added      */
 
201
  st_join_table *last_inner;    /**< last table table for embedding outer join */
 
202
  st_join_table *first_upper;  /**< first inner table for embedding outer join */
 
203
  st_join_table *first_unmatched; /**< used for optimization purposes only     */
 
204
  
 
205
  /* Special content for EXPLAIN 'Extra' column or NULL if none */
 
206
  const char    *info;
 
207
  /* 
 
208
    Bitmap of TAB_INFO_* bits that encodes special line for EXPLAIN 'Extra'
 
209
    column, or 0 if there is no info.
 
210
  */
 
211
  uint          packed_info;
 
212
 
 
213
  Read_record_func read_first_record;
 
214
  Next_select_func next_select;
 
215
  READ_RECORD   read_record;
 
216
  /* 
 
217
    Currently the following two fields are used only for a [NOT] IN subquery
 
218
    if it is executed by an alternative full table scan when the left operand of
 
219
    the subquery predicate is evaluated to NULL.
 
220
  */  
 
221
  Read_record_func save_read_first_record;/* to save read_first_record */ 
 
222
  int (*save_read_record) (READ_RECORD *);/* to save read_record.read_record */
 
223
  double        worst_seeks;
 
224
  key_map       const_keys;                     /**< Keys with constant part */
 
225
  key_map       checked_keys;                   /**< Keys checked in find_best */
 
226
  key_map       needed_reg;
 
227
  key_map       keys;                           /**< all keys with can be used */
 
228
 
 
229
  /* Either #rows in the table or 1 for const table.  */
 
230
  ha_rows       records;
 
231
  /*
 
232
    Number of records that will be scanned (yes scanned, not returned) by the
 
233
    best 'independent' access method, i.e. table scan or QUICK_*_SELECT)
 
234
  */
 
235
  ha_rows       found_records;
 
236
  /*
 
237
    Cost of accessing the table using "ALL" or range/index_merge access
 
238
    method (but not 'index' for some reason), i.e. this matches method which
 
239
    E(#records) is in found_records.
 
240
  */
 
241
  ha_rows       read_time;
 
242
  
 
243
  table_map     dependent,key_dependent;
 
244
  uint          use_quick,index;
 
245
  uint          status;                         ///< Save status for cache
 
246
  uint          used_fields,used_fieldlength,used_blobs;
 
247
  enum join_type type;
 
248
  bool          cached_eq_ref_table,eq_ref_table,not_used_in_distinct;
 
249
  /* TRUE <=> index-based access method must return records in order */
 
250
  bool          sorted;
 
251
  /* 
 
252
    If it's not 0 the number stored this field indicates that the index
 
253
    scan has been chosen to access the table data and we expect to scan 
 
254
    this number of rows for the table.
 
255
  */ 
 
256
  ha_rows       limit; 
 
257
  TABLE_REF     ref;
 
258
  JOIN_CACHE    cache;
 
259
  JOIN          *join;
 
260
  /** Bitmap of nested joins this table is part of */
 
261
 
 
262
  /* SemiJoinDuplicateElimination variables: */
 
263
  /*
 
264
    Embedding SJ-nest (may be not the direct parent), or NULL if none.
 
265
    This variable holds the result of table pullout.
 
266
  */
 
267
  TABLE_LIST    *emb_sj_nest;
 
268
 
 
269
  /* Variables for semi-join duplicate elimination */
 
270
  SJ_TMP_TABLE  *flush_weedout_table;
 
271
  SJ_TMP_TABLE  *check_weed_out_table;
 
272
  struct st_join_table  *do_firstmatch;
 
273
 
 
274
  /* 
 
275
     ptr  - this join tab should do an InsideOut scan. Points 
 
276
            to the tab for which we'll need to check tab->found_match.
 
277
 
 
278
     NULL - Not an insideout scan.
 
279
  */
 
280
  struct st_join_table *insideout_match_tab;
 
281
  uchar *insideout_buf; // Buffer to save index tuple to be able to skip dups
 
282
 
 
283
  /* Used by InsideOut scan. Just set to true when have found a row. */
 
284
  bool found_match;
 
285
 
 
286
  enum { 
 
287
    /* If set, the rowid of this table must be put into the temptable. */
 
288
    KEEP_ROWID=1, 
 
289
    /* 
 
290
      If set, one should call h->position() to obtain the rowid,
 
291
      otherwise, the rowid is assumed to already be in h->ref
 
292
      (this is because join caching and filesort() save the rowid and then
 
293
      put it back into h->ref)
 
294
    */
 
295
    CALL_POSITION=2
 
296
  };
 
297
  /* A set of flags from the above enum */
 
298
  int  rowid_keep_flags;
 
299
 
 
300
 
 
301
  /* NestedOuterJoins: Bitmap of nested joins this table is part of */
 
302
  nested_join_map embedding_map;
 
303
 
 
304
  void cleanup();
 
305
  inline bool is_using_loose_index_scan()
 
306
  {
 
307
    return (select && select->quick &&
 
308
            (select->quick->get_type() ==
 
309
             QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX));
 
310
  }
 
311
} JOIN_TAB;
 
312
 
 
313
enum_nested_loop_state sub_select_cache(JOIN *join, JOIN_TAB *join_tab, bool
 
314
                                        end_of_records);
 
315
enum_nested_loop_state sub_select(JOIN *join,JOIN_TAB *join_tab, bool
 
316
                                  end_of_records);
 
317
enum_nested_loop_state end_send_group(JOIN *join, JOIN_TAB *join_tab,
 
318
                                      bool end_of_records);
 
319
enum_nested_loop_state end_write_group(JOIN *join, JOIN_TAB *join_tab,
 
320
                                       bool end_of_records);
 
321
 
 
322
/**
 
323
  Information about a position of table within a join order. Used in join
 
324
  optimization.
 
325
*/
 
326
typedef struct st_position
 
327
{
 
328
  /*
 
329
    The "fanout": number of output rows that will be produced (after
 
330
    pushed down selection condition is applied) per each row combination of
 
331
    previous tables.
 
332
  */
 
333
  double records_read;
 
334
 
 
335
  /* 
 
336
    Cost accessing the table in course of the entire complete join execution,
 
337
    i.e. cost of one access method use (e.g. 'range' or 'ref' scan ) times 
 
338
    number the access method will be invoked.
 
339
  */
 
340
  double read_time;
 
341
  JOIN_TAB *table;
 
342
 
 
343
  /*
 
344
    NULL  -  'index' or 'range' or 'index_merge' or 'ALL' access is used.
 
345
    Other - [eq_]ref[_or_null] access is used. Pointer to {t.keypart1 = expr}
 
346
  */
 
347
  KEYUSE *key;
 
348
 
 
349
  /* If ref-based access is used: bitmap of tables this table depends on  */
 
350
  table_map ref_depend_map;
 
351
 
 
352
  bool use_insideout_scan;
 
353
} POSITION;
 
354
 
58
355
 
59
356
typedef struct st_rollup
60
357
{
65
362
  List<Item> *fields;
66
363
} ROLLUP;
67
364
 
68
 
} /* namespace drizzled */
69
 
 
70
 
/** @TODO why is this in the middle of the file??? */
71
 
 
72
 
#include "drizzled/join.h"
73
 
 
74
 
namespace drizzled
75
 
{
76
 
 
77
 
/*****************************************************************************
78
 
  Make som simple condition optimization:
79
 
  If there is a test 'field = const' change all refs to 'field' to 'const'
80
 
  Remove all dummy tests 'item = item', 'const op const'.
81
 
  Remove all 'item is NULL', when item can never be null!
82
 
  item->marker should be 0 for all items on entry
83
 
  Return in cond_value false if condition is impossible (1 = 2)
84
 
*****************************************************************************/
85
 
struct COND_CMP {
86
 
  Item *and_level;
87
 
  Item_func *cmp_func;
88
 
  COND_CMP(Item *a,Item_func *b) :and_level(a),cmp_func(b) {}
89
 
};
90
 
 
91
 
void TEST_join(Join *join);
 
365
 
 
366
/*
 
367
  Describes use of one temporary table to weed out join duplicates.
 
368
  The temporar
 
369
 
 
370
  Used to
 
371
    - create a temp table
 
372
    - when we reach the weed-out tab, walk through rowid-ed tabs and
 
373
      and copy rowids.
 
374
      For each table we need
 
375
       - rowid offset
 
376
       - null bit address.
 
377
*/
 
378
 
 
379
class SJ_TMP_TABLE : public Sql_alloc
 
380
{
 
381
public:
 
382
  /* Array of pointers to tables that should be "used" */
 
383
  class TAB
 
384
  {
 
385
  public:
 
386
    JOIN_TAB *join_tab;
 
387
    uint rowid_offset;
 
388
    ushort null_byte;
 
389
    uchar null_bit;
 
390
  };
 
391
  TAB *tabs;
 
392
  TAB *tabs_end;
 
393
 
 
394
  uint null_bits;
 
395
  uint null_bytes;
 
396
  uint rowid_len;
 
397
 
 
398
  TABLE *tmp_table;
 
399
 
 
400
  MI_COLUMNDEF *start_recinfo;
 
401
  MI_COLUMNDEF *recinfo;
 
402
 
 
403
  /* Pointer to next table (next->start_idx > this->end_idx) */
 
404
  SJ_TMP_TABLE *next; 
 
405
};
 
406
 
 
407
 
 
408
class JOIN :public Sql_alloc
 
409
{
 
410
  JOIN(const JOIN &rhs);                        /**< not implemented */
 
411
  JOIN& operator=(const JOIN &rhs);             /**< not implemented */
 
412
public:
 
413
  JOIN_TAB *join_tab,**best_ref;
 
414
  JOIN_TAB **map2table;    ///< mapping between table indexes and JOIN_TABs
 
415
  JOIN_TAB *join_tab_save; ///< saved join_tab for subquery reexecution
 
416
  TABLE    **table,**all_tables;
 
417
  /**
 
418
    The table which has an index that allows to produce the requried ordering.
 
419
    A special value of 0x1 means that the ordering will be produced by
 
420
    passing 1st non-const table to filesort(). NULL means no such table exists.
 
421
  */
 
422
  TABLE    *sort_by_table;
 
423
  uint     tables;        /**< Number of tables in the join */
 
424
  uint     outer_tables;  /**< Number of tables that are not inside semijoin */
 
425
  uint     const_tables;
 
426
  uint     send_group_parts;
 
427
  bool     sort_and_group,first_record,full_join,group, no_field_update;
 
428
  bool     do_send_rows;
 
429
  /**
 
430
    TRUE when we want to resume nested loop iterations when
 
431
    fetching data from a cursor
 
432
  */
 
433
  bool     resume_nested_loop;
 
434
  table_map const_table_map,found_const_table_map,outer_join;
 
435
  ha_rows  send_records,found_records,examined_rows,row_limit, select_limit;
 
436
  /**
 
437
    Used to fetch no more than given amount of rows per one
 
438
    fetch operation of server side cursor.
 
439
    The value is checked in end_send and end_send_group in fashion, similar
 
440
    to offset_limit_cnt:
 
441
      - fetch_limit= HA_POS_ERROR if there is no cursor.
 
442
      - when we open a cursor, we set fetch_limit to 0,
 
443
      - on each fetch iteration we add num_rows to fetch to fetch_limit
 
444
  */
 
445
  ha_rows  fetch_limit;
 
446
  POSITION positions[MAX_TABLES+1],best_positions[MAX_TABLES+1];
 
447
  
 
448
  /* *
 
449
    Bitmap of nested joins embedding the position at the end of the current 
 
450
    partial join (valid only during join optimizer run).
 
451
  */
 
452
  nested_join_map cur_embedding_map;
 
453
 
 
454
  double   best_read;
 
455
  List<Item> *fields;
 
456
  List<Cached_item> group_fields, group_fields_cache;
 
457
  TABLE    *tmp_table;
 
458
  /// used to store 2 possible tmp table of SELECT
 
459
  TABLE    *exec_tmp_table1, *exec_tmp_table2;
 
460
  THD      *thd;
 
461
  Item_sum  **sum_funcs, ***sum_funcs_end;
 
462
  /** second copy of sumfuncs (for queries with 2 temporary tables */
 
463
  Item_sum  **sum_funcs2, ***sum_funcs_end2;
 
464
  Item      *having;
 
465
  Item      *tmp_having; ///< To store having when processed temporary table
 
466
  Item      *having_history; ///< Store having for explain
 
467
  ulonglong  select_options;
 
468
  select_result *result;
 
469
  TMP_TABLE_PARAM tmp_table_param;
 
470
  MYSQL_LOCK *lock;
 
471
  /// unit structure (with global parameters) for this select
 
472
  SELECT_LEX_UNIT *unit;
 
473
  /// select that processed
 
474
  SELECT_LEX *select_lex;
 
475
  /** 
 
476
    TRUE <=> optimizer must not mark any table as a constant table.
 
477
    This is needed for subqueries in form "a IN (SELECT .. UNION SELECT ..):
 
478
    when we optimize the select that reads the results of the union from a
 
479
    temporary table, we must not mark the temp. table as constant because
 
480
    the number of rows in it may vary from one subquery execution to another.
 
481
  */
 
482
  bool no_const_tables; 
 
483
  
 
484
  JOIN *tmp_join; ///< copy of this JOIN to be used with temporary tables
 
485
  ROLLUP rollup;                                ///< Used with rollup
 
486
 
 
487
  bool select_distinct;                         ///< Set if SELECT DISTINCT
 
488
  /**
 
489
    If we have the GROUP BY statement in the query,
 
490
    but the group_list was emptied by optimizer, this
 
491
    flag is TRUE.
 
492
    It happens when fields in the GROUP BY are from
 
493
    constant table
 
494
  */
 
495
  bool group_optimized_away;
 
496
 
 
497
  /*
 
498
    simple_xxxxx is set if ORDER/GROUP BY doesn't include any references
 
499
    to other tables than the first non-constant table in the JOIN.
 
500
    It's also set if ORDER/GROUP BY is empty.
 
501
  */
 
502
  bool simple_order, simple_group;
 
503
  /**
 
504
    Is set only in case if we have a GROUP BY clause
 
505
    and no ORDER BY after constant elimination of 'order'.
 
506
  */
 
507
  bool no_order;
 
508
  /** Is set if we have a GROUP BY and we have ORDER BY on a constant. */
 
509
  bool          skip_sort_order;
 
510
 
 
511
  bool need_tmp, hidden_group_fields;
 
512
  DYNAMIC_ARRAY keyuse;
 
513
  Item::cond_result cond_value, having_value;
 
514
  List<Item> all_fields; ///< to store all fields that used in query
 
515
  ///Above list changed to use temporary table
 
516
  List<Item> tmp_all_fields1, tmp_all_fields2, tmp_all_fields3;
 
517
  ///Part, shared with list above, emulate following list
 
518
  List<Item> tmp_fields_list1, tmp_fields_list2, tmp_fields_list3;
 
519
  List<Item> &fields_list; ///< hold field list passed to mysql_select
 
520
  int error;
 
521
 
 
522
  ORDER *order, *group_list, *proc_param; //hold parameters of mysql_select
 
523
  COND *conds;                            // ---"---
 
524
  Item *conds_history;                    // store WHERE for explain
 
525
  TABLE_LIST *tables_list;           ///<hold 'tables' parameter of mysql_select
 
526
  List<TABLE_LIST> *join_list;       ///< list of joined tables in reverse order
 
527
  COND_EQUAL *cond_equal;
 
528
  SQL_SELECT *select;                ///<created in optimisation phase
 
529
  JOIN_TAB *return_tab;              ///<used only for outer joins
 
530
  Item **ref_pointer_array; ///<used pointer reference for this select
 
531
  // Copy of above to be used with different lists
 
532
  Item **items0, **items1, **items2, **items3, **current_ref_pointer_array;
 
533
  uint ref_pointer_array_size; ///< size of above in bytes
 
534
  const char *zero_result_cause; ///< not 0 if exec must return zero result
 
535
  
 
536
  bool union_part; ///< this subselect is part of union 
 
537
  bool optimized; ///< flag to avoid double optimization in EXPLAIN
 
538
  
 
539
  Array<Item_in_subselect> sj_subselects;
 
540
 
 
541
  /* Descriptions of temporary tables used to weed-out semi-join duplicates */
 
542
  SJ_TMP_TABLE  *sj_tmp_tables;
 
543
 
 
544
  table_map cur_emb_sj_nests;
 
545
 
 
546
  /* 
 
547
    storage for caching buffers allocated during query execution. 
 
548
    These buffers allocations need to be cached as the thread memory pool is
 
549
    cleared only at the end of the execution of the whole query and not caching
 
550
    allocations that occur in repetition at execution time will result in 
 
551
    excessive memory usage.
 
552
  */  
 
553
  SORT_FIELD *sortorder;                        // make_unireg_sortorder()
 
554
  TABLE **table_reexec;                         // make_simple_join()
 
555
  JOIN_TAB *join_tab_reexec;                    // make_simple_join()
 
556
  /* end of allocation caching storage */
 
557
 
 
558
  JOIN(THD *thd_arg, List<Item> &fields_arg, ulonglong select_options_arg,
 
559
       select_result *result_arg)
 
560
    :fields_list(fields_arg), sj_subselects(thd_arg->mem_root, 4)
 
561
  {
 
562
    init(thd_arg, fields_arg, select_options_arg, result_arg);
 
563
  }
 
564
 
 
565
  void init(THD *thd_arg, List<Item> &fields_arg, ulonglong select_options_arg,
 
566
       select_result *result_arg)
 
567
  {
 
568
    join_tab= join_tab_save= 0;
 
569
    table= 0;
 
570
    tables= 0;
 
571
    const_tables= 0;
 
572
    join_list= 0;
 
573
    sort_and_group= 0;
 
574
    first_record= 0;
 
575
    do_send_rows= 1;
 
576
    resume_nested_loop= FALSE;
 
577
    send_records= 0;
 
578
    found_records= 0;
 
579
    fetch_limit= HA_POS_ERROR;
 
580
    examined_rows= 0;
 
581
    exec_tmp_table1= 0;
 
582
    exec_tmp_table2= 0;
 
583
    sortorder= 0;
 
584
    table_reexec= 0;
 
585
    join_tab_reexec= 0;
 
586
    thd= thd_arg;
 
587
    sum_funcs= sum_funcs2= 0;
 
588
    having= tmp_having= having_history= 0;
 
589
    select_options= select_options_arg;
 
590
    result= result_arg;
 
591
    lock= thd_arg->lock;
 
592
    select_lex= 0; //for safety
 
593
    tmp_join= 0;
 
594
    select_distinct= test(select_options & SELECT_DISTINCT);
 
595
    no_order= 0;
 
596
    simple_order= 0;
 
597
    simple_group= 0;
 
598
    skip_sort_order= 0;
 
599
    need_tmp= 0;
 
600
    hidden_group_fields= 0; /*safety*/
 
601
    error= 0;
 
602
    select= 0;
 
603
    return_tab= 0;
 
604
    ref_pointer_array= items0= items1= items2= items3= 0;
 
605
    ref_pointer_array_size= 0;
 
606
    zero_result_cause= 0;
 
607
    optimized= 0;
 
608
    cond_equal= 0;
 
609
    group_optimized_away= 0;
 
610
 
 
611
    all_fields= fields_arg;
 
612
    fields_list= fields_arg;
 
613
    bzero((char*) &keyuse,sizeof(keyuse));
 
614
    tmp_table_param.init();
 
615
    tmp_table_param.end_write_records= HA_POS_ERROR;
 
616
    rollup.state= ROLLUP::STATE_NONE;
 
617
    sj_tmp_tables= NULL;
 
618
 
 
619
    no_const_tables= FALSE;
 
620
  }
 
621
 
 
622
  int prepare(Item ***rref_pointer_array, TABLE_LIST *tables, uint wind_num,
 
623
              COND *conds, uint og_num, ORDER *order, ORDER *group,
 
624
              Item *having, ORDER *proc_param, SELECT_LEX *select,
 
625
              SELECT_LEX_UNIT *unit);
 
626
  int optimize();
 
627
  int reinit();
 
628
  void exec();
 
629
  int destroy();
 
630
  void restore_tmp();
 
631
  bool alloc_func_list();
 
632
  bool flatten_subqueries();
 
633
  bool setup_subquery_materialization();
 
634
  bool make_sum_func_list(List<Item> &all_fields, List<Item> &send_fields,
 
635
                          bool before_group_by, bool recompute= FALSE);
 
636
 
 
637
  inline void set_items_ref_array(Item **ptr)
 
638
  {
 
639
    memcpy((char*) ref_pointer_array, (char*) ptr, ref_pointer_array_size);
 
640
    current_ref_pointer_array= ptr;
 
641
  }
 
642
  inline void init_items_ref_array()
 
643
  {
 
644
    items0= ref_pointer_array + all_fields.elements;
 
645
    memcpy(items0, ref_pointer_array, ref_pointer_array_size);
 
646
    current_ref_pointer_array= items0;
 
647
  }
 
648
 
 
649
  bool rollup_init();
 
650
  bool rollup_make_fields(List<Item> &all_fields, List<Item> &fields,
 
651
                          Item_sum ***func);
 
652
  int rollup_send_data(uint idx);
 
653
  int rollup_write_data(uint idx, TABLE *table);
 
654
  void remove_subq_pushed_predicates(Item **where);
 
655
  /**
 
656
    Release memory and, if possible, the open tables held by this execution
 
657
    plan (and nested plans). It's used to release some tables before
 
658
    the end of execution in order to increase concurrency and reduce
 
659
    memory consumption.
 
660
  */
 
661
  void join_free();
 
662
  /** Cleanup this JOIN, possibly for reuse */
 
663
  void cleanup(bool full);
 
664
  void clear();
 
665
  bool save_join_tab();
 
666
  bool init_save_join_tab();
 
667
  bool send_row_on_empty_set()
 
668
  {
 
669
    return (do_send_rows && tmp_table_param.sum_func_count != 0 &&
 
670
            !group_list);
 
671
  }
 
672
  bool change_result(select_result *result);
 
673
  bool is_top_level_join() const
 
674
  {
 
675
    return (unit == &thd->lex->unit && (unit->fake_select_lex == 0 ||
 
676
                                        select_lex == unit->fake_select_lex));
 
677
  }
 
678
};
 
679
 
 
680
 
 
681
typedef struct st_select_check {
 
682
  uint const_ref,reg_ref;
 
683
} SELECT_CHECK;
 
684
 
 
685
extern const char *join_type_str[];
 
686
void TEST_join(JOIN *join);
92
687
 
93
688
/* Extern functions in sql_select.cc */
94
689
bool store_val_in_field(Field *field, Item *val, enum_check_fields check_flag);
95
 
Table *create_tmp_table(Session *session,Tmp_Table_Param *param,List<Item> &fields,
96
 
                        order_st *group, bool distinct, bool save_sum_fields,
97
 
                        uint64_t select_options, ha_rows rows_limit,
98
 
                        const char* alias);
99
 
void count_field_types(Select_Lex *select_lex, Tmp_Table_Param *param,
 
690
TABLE *create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
 
691
                        ORDER *group, bool distinct, bool save_sum_fields,
 
692
                        ulonglong select_options, ha_rows rows_limit,
 
693
                        char* alias);
 
694
void free_tmp_table(THD *thd, TABLE *entry);
 
695
void count_field_types(SELECT_LEX *select_lex, TMP_TABLE_PARAM *param, 
100
696
                       List<Item> &fields, bool reset_with_sum_func);
101
 
bool setup_copy_fields(Session *session, Tmp_Table_Param *param,
 
697
bool setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param,
102
698
                       Item **ref_pointer_array,
103
699
                       List<Item> &new_list1, List<Item> &new_list2,
104
 
                       uint32_t elements, List<Item> &fields);
105
 
void copy_fields(Tmp_Table_Param *param);
 
700
                       uint elements, List<Item> &fields);
 
701
void copy_fields(TMP_TABLE_PARAM *param);
106
702
void copy_funcs(Item **func_ptr);
107
 
Field* create_tmp_field_from_field(Session *session, Field* org_field,
108
 
                                   const char *name, Table *table,
109
 
                                   Item_field *item, uint32_t convert_blob_length);
110
 
bool test_if_ref(Item_field *left_item,Item *right_item);
111
 
COND *optimize_cond(Join *join, COND *conds, List<TableList> *join_list, Item::cond_result *cond_value);
112
 
COND *make_cond_for_table(COND *cond,table_map table, table_map used_table, bool exclude_expensive_cond);
113
 
COND* substitute_for_best_equal_field(COND *cond, COND_EQUAL *cond_equal, void *table_join_idx);
114
 
bool list_contains_unique_index(Table *table, bool (*find_func) (Field *, void *), void *data);
115
 
bool find_field_in_order_list (Field *field, void *data);
116
 
bool find_field_in_item_list (Field *field, void *data);
117
 
bool test_if_skip_sort_order(JoinTable *tab,order_st *order,ha_rows select_limit, bool no_changes, const key_map *map);
118
 
order_st *create_distinct_group(Session *session,
119
 
                                Item **ref_pointer_array,
120
 
                                order_st *order_list,
121
 
                                List<Item> &fields,
122
 
                                List<Item> &,
123
 
                                bool *all_order_by_fields_used);
124
 
// Create list for using with tempory table
125
 
bool change_to_use_tmp_fields(Session *session,
126
 
                              Item **ref_pointer_array,
127
 
                                                List<Item> &res_selected_fields,
128
 
                                                List<Item> &res_all_fields,
129
 
                                                uint32_t elements,
130
 
                              List<Item> &all_fields);
131
 
int do_select(Join *join, List<Item> *fields, Table *tmp_table);
132
 
bool const_expression_in_where(COND *conds,Item *item, Item **comp_item);
133
 
int create_sort_index(Session *session, Join *join, order_st *order, ha_rows filesort_limit, ha_rows select_limit, bool is_order_by);
134
 
void save_index_subquery_explain_info(JoinTable *join_tab, Item* where);
135
 
Item *remove_additional_cond(Item* conds);
136
 
bool setup_sum_funcs(Session *session, Item_sum **func_ptr);
137
 
bool init_sum_functions(Item_sum **func, Item_sum **end);
138
 
bool update_sum_func(Item_sum **func);
139
 
void copy_sum_funcs(Item_sum **func_ptr, Item_sum **end);
140
 
bool change_refs_to_tmp_fields(Session *session,
141
 
                               Item **ref_pointer_array,
142
 
                               List<Item> &res_selected_fields,
143
 
                               List<Item> &res_all_fields,
144
 
                               uint32_t elements,
145
 
                                                 List<Item> &all_fields);
146
 
bool change_group_ref(Session *session, Item_func *expr, order_st *group_list, bool *changed);
147
 
bool check_interleaving_with_nj(JoinTable *next);
148
 
 
149
 
int join_read_const_table(JoinTable *tab, optimizer::Position *pos);
150
 
int join_read_system(JoinTable *tab);
151
 
int join_read_const(JoinTable *tab);
152
 
int join_read_key(JoinTable *tab);
153
 
int join_read_always_key(JoinTable *tab);
154
 
int join_read_last_key(JoinTable *tab);
155
 
int join_no_more_records(ReadRecord *info);
156
 
int join_read_next(ReadRecord *info);
157
 
int join_read_next_different(ReadRecord *info);
158
 
int join_init_quick_read_record(JoinTable *tab);
159
 
int init_read_record_seq(JoinTable *tab);
160
 
int test_if_quick_select(JoinTable *tab);
161
 
int join_init_read_record(JoinTable *tab);
162
 
int join_read_first(JoinTable *tab);
163
 
int join_read_next_same(ReadRecord *info);
164
 
int join_read_next_same_diff(ReadRecord *info);
165
 
int join_read_last(JoinTable *tab);
166
 
int join_read_prev_same(ReadRecord *info);
167
 
int join_read_prev(ReadRecord *info);
168
 
int join_read_always_key_or_null(JoinTable *tab);
169
 
int join_read_next_same_or_null(ReadRecord *info);
170
 
 
171
 
void calc_used_field_length(Session *, JoinTable *join_tab);
172
 
StoredKey *get_store_key(Session *session, 
173
 
                         optimizer::KeyUse *keyuse,
174
 
                         table_map used_tables,
175
 
                         KeyPartInfo *key_part,
176
 
                         unsigned char *key_buff,
177
 
                         uint32_t maybe_null);
178
 
int join_tab_cmp(const void* ptr1, const void* ptr2);
179
 
int join_tab_cmp_straight(const void* ptr1, const void* ptr2);
180
 
void push_index_cond(JoinTable *tab, uint32_t keyno, bool other_tbls_ok);
181
 
void add_not_null_conds(Join *join);
182
 
uint32_t max_part_bit(key_part_map bits);
183
 
COND *add_found_match_trig_cond(JoinTable *tab, COND *cond, JoinTable *root_tab);
184
 
order_st *create_distinct_group(Session *session,
185
 
                                Item **ref_pointer_array,
186
 
                                order_st *order,
187
 
                                List<Item> &fields,
188
 
                                List<Item> &all_fields,
189
 
                                bool *all_order_by_fields_used);
190
 
bool eq_ref_table(Join *join, order_st *start_order, JoinTable *tab);
191
 
int remove_dup_with_compare(Session *session, Table *table, Field **first_field, uint32_t offset, Item *having);
192
 
int remove_dup_with_hash_index(Session *session, 
193
 
                               Table *table,
194
 
                               uint32_t field_count,
195
 
                               Field **first_field,
196
 
                               uint32_t key_length,
197
 
                               Item *having);
198
 
bool update_ref_and_keys(Session *session,
199
 
                         DYNAMIC_ARRAY *keyuse,
200
 
                         JoinTable *join_tab,
201
 
                         uint32_t tables,
202
 
                         COND *cond, 
203
 
                         COND_EQUAL *,
204
 
                         table_map normal_tables,
205
 
                         Select_Lex *select_lex,
206
 
                         std::vector<optimizer::SargableParam> &sargables);
207
 
ha_rows get_quick_record_count(Session *session, optimizer::SqlSelect *select, Table *table, const key_map *keys,ha_rows limit);
208
 
void optimize_keyuse(Join *join, DYNAMIC_ARRAY *keyuse_array);
209
 
void add_group_and_distinct_keys(Join *join, JoinTable *join_tab);
210
 
void read_cached_record(JoinTable *tab);
211
 
bool mysql_select(Session *session, Item ***rref_pointer_array,
212
 
                  TableList *tables, uint32_t wild_num,  List<Item> &list,
213
 
                  COND *conds, uint32_t og_num, order_st *order, order_st *group,
214
 
                  Item *having, uint64_t select_type,
215
 
                  select_result *result, Select_Lex_Unit *unit,
216
 
                  Select_Lex *select_lex);
217
 
// Create list for using with tempory table
218
 
void init_tmptable_sum_functions(Item_sum **func);
219
 
void update_tmptable_sum_func(Item_sum **func,Table *tmp_table);
220
 
bool only_eq_ref_tables(Join *join, order_st *order, table_map tables);
221
 
bool create_ref_for_key(Join *join, JoinTable *j, 
222
 
                        optimizer::KeyUse *org_keyuse, 
223
 
                        table_map used_tables);
224
 
 
225
 
} /* namespace drizzled */
226
 
 
227
 
/** @TODO why is this in the middle of the file??? */
228
 
 
229
 
#include "drizzled/stored_key.h"
230
 
 
231
 
namespace drizzled
232
 
{
233
 
 
234
 
bool cp_buffer_from_ref(Session *session, table_reference_st *ref);
235
 
int safe_index_read(JoinTable *tab);
236
 
COND *remove_eq_conds(Session *session, COND *cond, Item::cond_result *cond_value);
 
703
bool create_myisam_from_heap(THD *thd, TABLE *table,
 
704
                             MI_COLUMNDEF *start_recinfo,
 
705
                             MI_COLUMNDEF **recinfo, 
 
706
                             int error, bool ignore_last_dupp_key_error);
 
707
uint find_shortest_key(TABLE *table, const key_map *usable_keys);
 
708
Field* create_tmp_field_from_field(THD *thd, Field* org_field,
 
709
                                   const char *name, TABLE *table,
 
710
                                   Item_field *item, uint convert_blob_length);
 
711
                                                                      
 
712
/* functions from opt_sum.cc */
 
713
bool simple_pred(Item_func *func_item, Item **args, bool *inv_order);
 
714
int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds);
 
715
 
 
716
/* from sql_delete.cc, used by opt_range.cc */
 
717
extern "C" int refpos_order_cmp(void* arg, const void *a,const void *b);
 
718
 
 
719
/** class to copying an field/item to a key struct */
 
720
 
 
721
class store_key :public Sql_alloc
 
722
{
 
723
public:
 
724
  bool null_key; /* TRUE <=> the value of the key has a null part */
 
725
  enum store_key_result { STORE_KEY_OK, STORE_KEY_FATAL, STORE_KEY_CONV };
 
726
  store_key(THD *thd, Field *field_arg, uchar *ptr, uchar *null, uint length)
 
727
    :null_key(0), null_ptr(null), err(0)
 
728
  {
 
729
    if (field_arg->type() == MYSQL_TYPE_BLOB)
 
730
    {
 
731
      /* 
 
732
        Key segments are always packed with a 2 byte length prefix.
 
733
        See mi_rkey for details.
 
734
      */
 
735
      to_field= new Field_varstring(ptr, length, 2, null, 1, 
 
736
                                    Field::NONE, field_arg->field_name,
 
737
                                    field_arg->table->s, field_arg->charset());
 
738
      to_field->init(field_arg->table);
 
739
    }
 
740
    else
 
741
      to_field=field_arg->new_key_field(thd->mem_root, field_arg->table,
 
742
                                        ptr, null, 1);
 
743
  }
 
744
  virtual ~store_key() {}                       /** Not actually needed */
 
745
  virtual const char *name() const=0;
 
746
 
 
747
  /**
 
748
    @brief sets ignore truncation warnings mode and calls the real copy method
 
749
 
 
750
    @details this function makes sure truncation warnings when preparing the
 
751
    key buffers don't end up as errors (because of an enclosing INSERT/UPDATE).
 
752
  */
 
753
  enum store_key_result copy()
 
754
  {
 
755
    enum store_key_result result;
 
756
    THD *thd= to_field->table->in_use;
 
757
    enum_check_fields saved_count_cuted_fields= thd->count_cuted_fields;
 
758
 
 
759
    thd->count_cuted_fields= CHECK_FIELD_IGNORE;
 
760
 
 
761
    result= copy_inner();
 
762
 
 
763
    thd->count_cuted_fields= saved_count_cuted_fields;
 
764
 
 
765
    return result;
 
766
  }
 
767
 
 
768
 protected:
 
769
  Field *to_field;                              // Store data here
 
770
  uchar *null_ptr;
 
771
  uchar err;
 
772
 
 
773
  virtual enum store_key_result copy_inner()=0;
 
774
};
 
775
 
 
776
 
 
777
class store_key_field: public store_key
 
778
{
 
779
  Copy_field copy_field;
 
780
  const char *field_name;
 
781
 public:
 
782
  store_key_field(THD *thd, Field *to_field_arg, uchar *ptr,
 
783
                  uchar *null_ptr_arg,
 
784
                  uint length, Field *from_field, const char *name_arg)
 
785
    :store_key(thd, to_field_arg,ptr,
 
786
               null_ptr_arg ? null_ptr_arg : from_field->maybe_null() ? &err
 
787
               : (uchar*) 0, length), field_name(name_arg)
 
788
  {
 
789
    if (to_field)
 
790
    {
 
791
      copy_field.set(to_field,from_field,0);
 
792
    }
 
793
  }
 
794
  const char *name() const { return field_name; }
 
795
 
 
796
 protected: 
 
797
  enum store_key_result copy_inner()
 
798
  {
 
799
    TABLE *table= copy_field.to_field->table;
 
800
    my_bitmap_map *old_map= dbug_tmp_use_all_columns(table,
 
801
                                                     table->write_set);
 
802
    copy_field.do_copy(&copy_field);
 
803
    dbug_tmp_restore_column_map(table->write_set, old_map);
 
804
    null_key= to_field->is_null();
 
805
    return err != 0 ? STORE_KEY_FATAL : STORE_KEY_OK;
 
806
  }
 
807
};
 
808
 
 
809
 
 
810
class store_key_item :public store_key
 
811
{
 
812
 protected:
 
813
  Item *item;
 
814
public:
 
815
  store_key_item(THD *thd, Field *to_field_arg, uchar *ptr,
 
816
                 uchar *null_ptr_arg, uint length, Item *item_arg)
 
817
    :store_key(thd, to_field_arg, ptr,
 
818
               null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
 
819
               &err : (uchar*) 0, length), item(item_arg)
 
820
  {}
 
821
  const char *name() const { return "func"; }
 
822
 
 
823
 protected:  
 
824
  enum store_key_result copy_inner()
 
825
  {
 
826
    TABLE *table= to_field->table;
 
827
    my_bitmap_map *old_map= dbug_tmp_use_all_columns(table,
 
828
                                                     table->write_set);
 
829
    int res= item->save_in_field(to_field, 1);
 
830
    dbug_tmp_restore_column_map(table->write_set, old_map);
 
831
    null_key= to_field->is_null() || item->null_value;
 
832
    return (err != 0 || res > 2 ? STORE_KEY_FATAL : (store_key_result) res); 
 
833
  }
 
834
};
 
835
 
 
836
 
 
837
class store_key_const_item :public store_key_item
 
838
{
 
839
  bool inited;
 
840
public:
 
841
  store_key_const_item(THD *thd, Field *to_field_arg, uchar *ptr,
 
842
                       uchar *null_ptr_arg, uint length,
 
843
                       Item *item_arg)
 
844
    :store_key_item(thd, to_field_arg,ptr,
 
845
                    null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
 
846
                    &err : (uchar*) 0, length, item_arg), inited(0)
 
847
  {
 
848
  }
 
849
  const char *name() const { return "const"; }
 
850
 
 
851
protected:  
 
852
  enum store_key_result copy_inner()
 
853
  {
 
854
    int res;
 
855
    if (!inited)
 
856
    {
 
857
      inited=1;
 
858
      if ((res= item->save_in_field(to_field, 1)))
 
859
      {       
 
860
        if (!err)
 
861
          err= res;
 
862
      }
 
863
    }
 
864
    null_key= to_field->is_null() || item->null_value;
 
865
    return (err > 2 ?  STORE_KEY_FATAL : (store_key_result) err);
 
866
  }
 
867
};
 
868
 
 
869
bool cp_buffer_from_ref(THD *thd, TABLE *table, TABLE_REF *ref);
 
870
bool error_if_full_join(JOIN *join);
 
871
int report_error(TABLE *table, int error);
 
872
int safe_index_read(JOIN_TAB *tab);
 
873
COND *remove_eq_conds(THD *thd, COND *cond, Item::cond_result *cond_value);
237
874
int test_if_item_cache_changed(List<Cached_item> &list);
238
 
 
239
 
void print_join(Session *session, String *str,
240
 
                List<TableList> *tables, enum_query_type);
241
 
 
242
 
} /* namespace drizzled */
243
 
 
244
 
#endif /* DRIZZLED_SQL_SELECT_H */