← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_list.h

  • Committer: Mark Atwood
  • Date: 2008-10-16 11:33:16 UTC
  • mto: (520.1.13 drizzle)
  • mto: This revision was merged to the branch mainline in revision 530.
  • Revision ID: mark@fallenpegasus.com-20081016113316-ff6jdt31ck90sjdh
an implemention of the errmsg plugin

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table_list.h
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#ifndef DRIZZLED_TABLE_LIST_H
22
 
#define DRIZZLED_TABLE_LIST_H
23
 
 
24
 
#include <drizzled/nested_join.h>
25
 
#include <drizzled/table.h>
26
 
 
27
 
namespace drizzled
28
 
{
 
21
 
 
22
#ifndef DRIZZLED_TMP_TABLE_H
 
23
#define DRIZZLED_TMP_TABLE_H
 
24
 
 
25
/*
 
26
  Table reference in the FROM clause.
 
27
 
 
28
  These table references can be of several types that correspond to
 
29
  different SQL elements. Below we list all types of TableLists with
 
30
  the necessary conditions to determine when a TableList instance
 
31
  belongs to a certain type.
 
32
 
 
33
  1) table (TableList::view == NULL)
 
34
     - base table
 
35
       (TableList::derived == NULL)
 
36
     - subquery - TableList::table is a temp table
 
37
       (TableList::derived != NULL)
 
38
     - information schema table
 
39
       (TableList::schema_table != NULL)
 
40
       NOTICE: for schema tables TableList::field_translation may be != NULL
 
41
  2) view (TableList::view != NULL)
 
42
     - merge    (TableList::effective_algorithm == VIEW_ALGORITHM_MERGE)
 
43
           also (TableList::field_translation != NULL)
 
44
     - tmptable (TableList::effective_algorithm == VIEW_ALGORITHM_TMPTABLE)
 
45
           also (TableList::field_translation == NULL)
 
46
  3) nested table reference (TableList::nested_join != NULL)
 
47
     - table sequence - e.g. (t1, t2, t3)
 
48
       TODO: how to distinguish from a JOIN?
 
49
     - general JOIN
 
50
       TODO: how to distinguish from a table sequence?
 
51
     - NATURAL JOIN
 
52
       (TableList::natural_join != NULL)
 
53
       - JOIN ... USING
 
54
         (TableList::join_using_fields != NULL)
 
55
     - semi-join
 
56
       ;
 
57
*/
 
58
 
 
59
 
 
60
#include "table.h"
29
61
 
30
62
class Index_hint;
31
63
class COND_EQUAL;
32
64
class Natural_join_column;
33
65
class select_union;
34
 
class Select_Lex_Unit;
35
 
class Select_Lex;
36
 
class Tmp_Table_Param;
 
66
class st_select_lex_unit;
 
67
class ST_SCHEMA_TABLE;
 
68
class st_select_lex;
 
69
class TMP_TABLE_PARAM;
 
70
class Field_translator;
37
71
class Item_subselect;
38
72
class Table;
39
73
 
40
 
namespace plugin
41
 
{
42
 
  class StorageEngine;
43
 
}
44
 
 
45
 
/**
46
 
 * A Table referenced in the FROM clause.
47
 
 *
48
 
 * These table references can be of several types that correspond to
49
 
 * different SQL elements. Below we list all types of TableLists with
50
 
 * the necessary conditions to determine when a TableList instance
51
 
 * belongs to a certain type.
52
 
 *
53
 
 * 1) table (TableList::view == NULL)
54
 
 *    - base table
55
 
 *    (TableList::derived == NULL)
56
 
 *    - subquery - TableList::table is a temp table
57
 
 *    (TableList::derived != NULL)
58
 
 *    
59
 
 *    @note
60
 
 *
61
 
 *    for schema tables TableList::field_translation may be != NULL
62
 
 *
63
 
 * 2) Was VIEW 
64
 
 * 3) nested table reference (TableList::nested_join != NULL)
65
 
 *     - table sequence - e.g. (t1, t2, t3)
66
 
 *     @todo how to distinguish from a JOIN?
67
 
 *     - general JOIN
68
 
 *     @todo how to distinguish from a table sequence?
69
 
 *     - NATURAL JOIN
70
 
 *     (TableList::natural_join != NULL)
71
 
 *     - JOIN ... USING
72
 
 *     (TableList::join_using_fields != NULL)
73
 
 *     - semi-join
74
 
 */
 
74
enum enum_schema_table_state
 
75
{ 
 
76
  NOT_PROCESSED= 0,
 
77
  PROCESSED_BY_CREATE_SORT_INDEX,
 
78
  PROCESSED_BY_JOIN_EXEC
 
79
};
 
80
 
 
81
 
75
82
class TableList
76
83
{
77
84
public:
78
 
  TableList():
79
 
    next_local(NULL),
80
 
    next_global(NULL),
81
 
    prev_global(NULL),
82
 
    db(NULL),
83
 
    alias(NULL),
84
 
    table_name(NULL),
85
 
    option(NULL),
86
 
    on_expr(NULL),
87
 
    table(NULL),
88
 
    prep_on_expr(NULL),
89
 
    cond_equal(NULL),
90
 
    natural_join(NULL),
91
 
    is_natural_join(false),
92
 
    is_join_columns_complete(false),
93
 
    straight(false),
94
 
    force_index(false),
95
 
    ignore_leaves(false),
96
 
    join_using_fields(NULL),
97
 
    join_columns(NULL),
98
 
    next_name_resolution_table(NULL),
99
 
    index_hints(NULL),
100
 
    derived_result(NULL),
101
 
    derived(NULL),
102
 
    schema_select_lex(NULL),
103
 
    select_lex(NULL),
104
 
    next_leaf(NULL),
105
 
    outer_join(0),
106
 
    db_length(0),
107
 
    table_name_length(0),
108
 
    dep_tables(0),
109
 
    on_expr_dep_tables(0),
110
 
    nested_join(NULL),
111
 
    embedding(NULL),
112
 
    join_list(NULL),
113
 
    db_type(NULL),
114
 
    internal_tmp_table(false),
115
 
    is_alias(false),
116
 
    is_fqtn(false),
117
 
    create(false)
118
 
  {}
 
85
  TableList() {}                          /* Remove gcc warning */
119
86
 
120
87
  /**
121
 
   * List of tables local to a subquery (used by SQL_LIST). Considers
122
 
   * views as leaves (unlike 'next_leaf' below). Created at parse time
123
 
   * in Select_Lex::add_table_to_list() -> table_list.link_in_list().
124
 
   */
 
88
    Prepare TableList that consists of one table instance to use in
 
89
    simple_open_and_lock_tables
 
90
  */
 
91
  inline void init_one_table(const char *db_name_arg,
 
92
                             const char *table_name_arg,
 
93
                             enum thr_lock_type lock_type_arg)
 
94
  {
 
95
    memset(this, 0, sizeof(*this));
 
96
    db= (char*) db_name_arg;
 
97
    table_name= alias= (char*) table_name_arg;
 
98
    lock_type= lock_type_arg;
 
99
  }
 
100
 
 
101
  /*
 
102
    List of tables local to a subquery (used by SQL_LIST). Considers
 
103
    views as leaves (unlike 'next_leaf' below). Created at parse time
 
104
    in st_select_lex::add_table_to_list() -> table_list.link_in_list().
 
105
  */
125
106
  TableList *next_local;
126
 
 
127
 
  /** link in a global list of all queries tables */
128
 
  TableList *next_global; 
129
 
  TableList **prev_global;
130
 
 
131
 
private:
132
 
  char *db;
133
 
 
134
 
public:
135
 
  const char *getSchemaName()
136
 
  {
137
 
    return db;
138
 
  }
139
 
 
140
 
  char **getSchemaNamePtr()
141
 
  {
142
 
    return &db;
143
 
  }
144
 
 
145
 
  void setSchemaName(char *arg)
146
 
  {
147
 
    db= arg;
148
 
  }
149
 
 
150
 
  const char *alias;
151
 
 
152
 
private:
153
 
  const char *table_name;
154
 
 
155
 
public:
156
 
  const char *getTableName()
157
 
  {
158
 
    return table_name;
159
 
  }
160
 
 
161
 
  void setTableName(const char *arg)
162
 
  {
163
 
    table_name= arg;
164
 
  }
165
 
 
166
 
  char *option; ///< Used by cache index
167
 
  Item *on_expr; ///< Used with outer join
168
 
  Table *table; ///< opened table
169
 
  /**
170
 
   * The structure of ON expression presented in the member above
171
 
   * can be changed during certain optimizations. This member
172
 
   * contains a snapshot of AND-OR structure of the ON expression
173
 
   * made after permanent transformations of the parse tree, and is
174
 
   * used to restore ON clause before every reexecution of a prepared
175
 
   * statement or stored procedure.
176
 
   */
177
 
  Item *prep_on_expr;
178
 
  COND_EQUAL *cond_equal; ///< Used with outer join
179
 
  /**
180
 
   * During parsing - left operand of NATURAL/USING join where 'this' is
181
 
   * the right operand. After parsing (this->natural_join == this) iff
182
 
   * 'this' represents a NATURAL or USING join operation. Thus after
183
 
   * parsing 'this' is a NATURAL/USING join iff (natural_join != NULL).
184
 
   */
 
107
  /* link in a global list of all queries tables */
 
108
  TableList *next_global, **prev_global;
 
109
  char          *db, *alias, *table_name, *schema_table_name;
 
110
  char          *option;                /* Used by cache index  */
 
111
  Item          *on_expr;               /* Used with outer join */
 
112
  Item          *sj_on_expr;
 
113
  /*
 
114
    (Valid only for semi-join nests) Bitmap of tables that are within the
 
115
    semi-join (this is different from bitmap of all nest's children because
 
116
    tables that were pulled out of the semi-join nest remain listed as
 
117
    nest's children).
 
118
  */
 
119
  table_map     sj_inner_tables;
 
120
  /* Number of IN-compared expressions */
 
121
  uint32_t          sj_in_exprs; 
 
122
  /*
 
123
    The structure of ON expression presented in the member above
 
124
    can be changed during certain optimizations. This member
 
125
    contains a snapshot of AND-OR structure of the ON expression
 
126
    made after permanent transformations of the parse tree, and is
 
127
    used to restore ON clause before every reexecution of a prepared
 
128
    statement or stored procedure.
 
129
  */
 
130
  Item          *prep_on_expr;
 
131
  COND_EQUAL    *cond_equal;            /* Used with outer join */
 
132
  /*
 
133
    During parsing - left operand of NATURAL/USING join where 'this' is
 
134
    the right operand. After parsing (this->natural_join == this) iff
 
135
    'this' represents a NATURAL or USING join operation. Thus after
 
136
    parsing 'this' is a NATURAL/USING join iff (natural_join != NULL).
 
137
  */
185
138
  TableList *natural_join;
186
 
  /**
187
 
   * True if 'this' represents a nested join that is a NATURAL JOIN.
188
 
   * For one of the operands of 'this', the member 'natural_join' points
189
 
   * to the other operand of 'this'.
190
 
   */
 
139
  /*
 
140
    True if 'this' represents a nested join that is a NATURAL JOIN.
 
141
    For one of the operands of 'this', the member 'natural_join' points
 
142
    to the other operand of 'this'.
 
143
  */
191
144
  bool is_natural_join;
192
 
 
193
 
  /** true if join_columns contains all columns of this table reference. */
194
 
  bool is_join_columns_complete;
195
 
 
196
 
  bool straight; ///< optimize with prev table
197
 
  bool force_index; ///< prefer index over table scan
198
 
  bool ignore_leaves; ///< preload only non-leaf nodes
199
 
 
200
 
  /*
201
 
    is the table a cartesian join, assumption is yes unless "solved"
202
 
  */
203
 
  bool isCartesian() const;
204
 
 
205
 
  /** Field names in a USING clause for JOIN ... USING. */
 
145
  /* Field names in a USING clause for JOIN ... USING. */
206
146
  List<String> *join_using_fields;
207
 
  /**
208
 
   * Explicitly store the result columns of either a NATURAL/USING join or
209
 
   * an operand of such a join.
210
 
   */
 
147
  /*
 
148
    Explicitly store the result columns of either a NATURAL/USING join or
 
149
    an operand of such a join.
 
150
  */
211
151
  List<Natural_join_column> *join_columns;
 
152
  /* true if join_columns contains all columns of this table reference. */
 
153
  bool is_join_columns_complete;
212
154
 
213
 
  /**
214
 
   * List of nodes in a nested join tree, that should be considered as
215
 
   * leaves with respect to name resolution. The leaves are: views,
216
 
   * top-most nodes representing NATURAL/USING joins, subqueries, and
217
 
   * base tables. All of these TableList instances contain a
218
 
   * materialized list of columns. The list is local to a subquery.
219
 
   */
 
155
  /*
 
156
    List of nodes in a nested join tree, that should be considered as
 
157
    leaves with respect to name resolution. The leaves are: views,
 
158
    top-most nodes representing NATURAL/USING joins, subqueries, and
 
159
    base tables. All of these TableList instances contain a
 
160
    materialized list of columns. The list is local to a subquery.
 
161
  */
220
162
  TableList *next_name_resolution_table;
221
 
  /** Index names in a "... JOIN ... USE/IGNORE INDEX ..." clause. */
 
163
  /* Index names in a "... JOIN ... USE/IGNORE INDEX ..." clause. */
222
164
  List<Index_hint> *index_hints;
223
 
  /**
224
 
   * select_result for derived table to pass it from table creation to table
225
 
   * filling procedure
226
 
   */
227
 
  select_union *derived_result;
228
 
  Select_Lex_Unit *derived; ///< Select_Lex_Unit of derived table */
229
 
  Select_Lex *schema_select_lex;
230
 
  /** link to select_lex where this table was used */
231
 
  Select_Lex *select_lex;
232
 
  /**
233
 
   * List of all base tables local to a subquery including all view
234
 
   * tables. Unlike 'next_local', this in this list views are *not*
235
 
   * leaves. Created in setup_tables() -> make_leaves_list().
236
 
   */
237
 
  TableList *next_leaf;
 
165
  Table        *table;    /* opened table */
 
166
  uint32_t          table_id; /* table id (from binlog) for opened table */
 
167
  /*
 
168
    select_result for derived table to pass it from table creation to table
 
169
    filling procedure
 
170
  */
 
171
  select_union  *derived_result;
 
172
  /*
 
173
    Reference from aux_tables to local list entry of main select of
 
174
    multi-delete statement:
 
175
    delete t1 from t2,t1 where t1.a<'B' and t2.b=t1.b;
 
176
    here it will be reference of first occurrence of t1 to second (as you
 
177
    can see this lists can't be merged)
 
178
  */
 
179
  TableList     *correspondent_table;
 
180
  st_select_lex_unit *derived;          /* SELECT_LEX_UNIT of derived table */
 
181
  ST_SCHEMA_TABLE *schema_table;        /* Information_schema table */
 
182
  st_select_lex *schema_select_lex;
 
183
  /*
 
184
    True when the view field translation table is used to convert
 
185
    schema table fields for backwards compatibility with SHOW command.
 
186
  */
 
187
  bool schema_table_reformed;
 
188
  TMP_TABLE_PARAM *schema_table_param;
 
189
  /* link to select_lex where this table was used */
 
190
  st_select_lex *select_lex;
 
191
  Field_translator *field_translation;  /* array of VIEW fields */
 
192
  /* pointer to element after last one in translation table above */
 
193
  Field_translator *field_translation_end;
 
194
  /*
 
195
    List (based on next_local) of underlying tables of this view. I.e. it
 
196
    does not include the tables of subqueries used in the view. Is set only
 
197
    for merged views.
 
198
  */
 
199
  TableList     *merge_underlying_list;
 
200
  /*
 
201
    List of all base tables local to a subquery including all view
 
202
    tables. Unlike 'next_local', this in this list views are *not*
 
203
    leaves. Created in setup_tables() -> make_leaves_list().
 
204
  */
 
205
  TableList     *next_leaf;
238
206
  thr_lock_type lock_type;
239
 
  uint32_t outer_join; ///< Which join type
240
 
  size_t db_length;
241
 
  size_t table_name_length;
 
207
  uint          outer_join;             /* Which join type */
 
208
  uint          shared;                 /* Used in multi-upd */
 
209
  size_t        db_length;
 
210
  size_t        table_name_length;
 
211
  bool          straight;               /* optimize with prev table */
 
212
  bool          updating;               /* for replicate-do/ignore table */
 
213
  bool          force_index;            /* prefer index over table scan */
 
214
  bool          ignore_leaves;          /* preload only non-leaf nodes */
 
215
  table_map     dep_tables;             /* tables the table depends on      */
 
216
  table_map     on_expr_dep_tables;     /* tables on expression depends on  */
 
217
  nested_join_st *nested_join;   /* if the element is a nested join  */
 
218
  TableList *embedding;             /* nested join containing the table */
 
219
  List<TableList> *join_list;/* join list the table belongs to   */
 
220
  bool          cacheable_table;        /* stop PS caching */
 
221
  handlerton    *db_type;               /* table_type for handler */
 
222
  char          timestamp_buffer[20];   /* buffer for timestamp (19+1) */
 
223
  /*
 
224
    This TableList object corresponds to the table to be created
 
225
    so it is possible that it does not exist (used in CREATE TABLE
 
226
    ... SELECT implementation).
 
227
  */
 
228
  bool          create;
 
229
  /* For transactional locking. */
 
230
  int           lock_timeout;           /* NOWAIT or WAIT [X]               */
 
231
  bool          lock_transactional;     /* If transactional lock requested. */
 
232
  bool          internal_tmp_table;
 
233
  /** true if an alias for this table was specified in the SQL. */
 
234
  bool          is_alias;
 
235
  /** true if the table is referred to in the statement using a fully
 
236
      qualified name (<db_name>.<table_name>).
 
237
  */
 
238
  bool          is_fqtn;
242
239
 
 
240
  uint32_t i_s_requested_object;
 
241
  bool has_db_lookup_value;
 
242
  bool has_table_lookup_value;
 
243
  uint32_t table_open_method;
 
244
  enum enum_schema_table_state schema_table_state;
243
245
  void set_underlying_merge();
244
 
  bool setup_underlying(Session *session);
245
 
 
246
 
  /**
247
 
   * If you change placeholder(), please check the condition in
248
 
   * check_transactional_lock() too.
249
 
   */
250
 
  bool placeholder();
251
 
  /**
252
 
   * Print table as it should be in join list.
253
 
   * 
254
 
   * @param str   string where table should be printed
255
 
   */
256
 
  void print(Session *session, String *str, enum_query_type query_type);
257
 
  /**
258
 
   * Sets insert_values buffer
259
 
   *
260
 
   * @param[in] memory pool for allocating
261
 
   *
262
 
   * @retval
263
 
   *  false - OK
264
 
   * @retval
265
 
   *  true - out of memory
266
 
   */
267
 
  bool set_insert_values(memory::Root *mem_root);
268
 
  /**
269
 
   * Find underlying base tables (TableList) which represent given
270
 
   * table_to_find (Table)
271
 
   *
272
 
   * @param[in] table to find
273
 
   *
274
 
   * @retval
275
 
   *  NULL if table is not found
276
 
   * @retval
277
 
   *  Pointer to found table reference
278
 
   */
 
246
  bool setup_underlying(THD *thd);
 
247
  void cleanup_items();
 
248
  /*
 
249
    If you change placeholder(), please check the condition in
 
250
    check_transactional_lock() too.
 
251
  */
 
252
  bool placeholder()
 
253
  {
 
254
    return derived || schema_table || (create && !table->getDBStat()) || !table;
 
255
  }
 
256
  void print(THD *thd, String *str, enum_query_type query_type);
 
257
  bool set_insert_values(MEM_ROOT *mem_root);
279
258
  TableList *find_underlying_table(Table *table);
280
 
  /**
281
 
   * Retrieve the first (left-most) leaf in a nested join tree with
282
 
   * respect to name resolution.
283
 
   *
284
 
   * @details
285
 
   *
286
 
   * Given that 'this' is a nested table reference, recursively walk
287
 
   * down the left-most children of 'this' until we reach a leaf
288
 
   * table reference with respect to name resolution.
289
 
   *
290
 
   * @retval
291
 
   *  If 'this' is a nested table reference - the left-most child of
292
 
   *  the tree rooted in 'this',
293
 
   *  else return 'this'
294
 
   */
295
259
  TableList *first_leaf_for_name_resolution();
296
 
  /**
297
 
   * Retrieve the last (right-most) leaf in a nested join tree with
298
 
   * respect to name resolution.
299
 
   *
300
 
   * @details
301
 
   *
302
 
   * Given that 'this' is a nested table reference, recursively walk
303
 
   * down the right-most children of 'this' until we reach a leaf
304
 
   * table reference with respect to name resolution.
305
 
   *
306
 
   * @retval
307
 
   *  If 'this' is a nested table reference - the right-most child of
308
 
   *  the tree rooted in 'this',
309
 
   *  else 'this'
310
 
   */
311
260
  TableList *last_leaf_for_name_resolution();
312
 
  /**
313
 
   * Test if this is a leaf with respect to name resolution.
314
 
   *
315
 
   * @details
316
 
   * 
317
 
   * A table reference is a leaf with respect to name resolution if
318
 
   * it is either a leaf node in a nested join tree (table, view,
319
 
   * schema table, subquery), or an inner node that represents a
320
 
   * NATURAL/USING join, or a nested join with materialized join
321
 
   * columns.
322
 
   *
323
 
   * @retval
324
 
   *  true if a leaf, false otherwise.
325
 
   */
326
261
  bool is_leaf_for_name_resolution();
327
262
  inline TableList *top_table()
328
 
  { return this; }
 
263
    { return this; }
329
264
 
330
 
  /**
331
 
   * Return subselect that contains the FROM list this table is taken from
332
 
   *
333
 
   * @retval
334
 
   *  Subselect item for the subquery that contains the FROM list
335
 
   *  this table is taken from if there is any
336
 
   * @retval
337
 
   *  NULL otherwise
338
 
   */
 
265
  /*
 
266
    Cleanup for re-execution in a prepared statement or a stored
 
267
    procedure.
 
268
  */
 
269
  void reinit_before_use(THD *thd);
339
270
  Item_subselect *containing_subselect();
340
271
 
341
 
  /**
342
 
   * Compiles the tagged hints list and fills up st_table::keys_in_use_for_query,
343
 
   * st_table::keys_in_use_for_group_by, st_table::keys_in_use_for_order_by,
344
 
   * st_table::force_index and st_table::covering_keys.
345
 
   *
346
 
   * @param the Table to operate on.
347
 
   *
348
 
   * @details
349
 
   *
350
 
   * The parser collects the index hints for each table in a "tagged list"
351
 
   * (TableList::index_hints). Using the information in this tagged list
352
 
   * this function sets the members Table::keys_in_use_for_query,
353
 
   * Table::keys_in_use_for_group_by, Table::keys_in_use_for_order_by,
354
 
   * Table::force_index and Table::covering_keys.
355
 
   *
356
 
   * Current implementation of the runtime does not allow mixing FORCE INDEX
357
 
   * and USE INDEX, so this is checked here. Then the FORCE INDEX list
358
 
   * (if non-empty) is appended to the USE INDEX list and a flag is set.
359
 
   * 
360
 
   * Multiple hints of the same kind are processed so that each clause
361
 
   * is applied to what is computed in the previous clause.
362
 
   * 
363
 
   * For example:
364
 
   *       USE INDEX (i1) USE INDEX (i2)
365
 
   *    is equivalent to
366
 
   *       USE INDEX (i1,i2)
367
 
   *    and means "consider only i1 and i2".
368
 
   *
369
 
   * Similarly
370
 
   *       USE INDEX () USE INDEX (i1)
371
 
   *    is equivalent to
372
 
   *       USE INDEX (i1)
373
 
   *    and means "consider only the index i1"
374
 
   *
375
 
   * It is OK to have the same index several times, e.g. "USE INDEX (i1,i1)" is
376
 
   * not an error.
377
 
   *
378
 
   * Different kind of hints (USE/FORCE/IGNORE) are processed in the following
379
 
   * order:
380
 
   *    1. All indexes in USE (or FORCE) INDEX are added to the mask.
381
 
   *    2. All IGNORE INDEX
382
 
   *       e.g. "USE INDEX i1, IGNORE INDEX i1, USE INDEX i1" will not use i1 at all
383
 
   *       as if we had "USE INDEX i1, USE INDEX i1, IGNORE INDEX i1".
384
 
   *       As an optimization if there is a covering index, and we have
385
 
   *       IGNORE INDEX FOR GROUP/order_st, and this index is used for the JOIN part,
386
 
   *       then we have to ignore the IGNORE INDEX FROM GROUP/order_st.
387
 
   *
388
 
   * @retval
389
 
   *   false no errors found
390
 
   * @retval
391
 
   *   true found and reported an error.
392
 
   */
 
272
  /* 
 
273
    Compiles the tagged hints list and fills up st_table::keys_in_use_for_query,
 
274
    st_table::keys_in_use_for_group_by, st_table::keys_in_use_for_order_by,
 
275
    st_table::force_index and st_table::covering_keys.
 
276
  */
393
277
  bool process_index_hints(Table *table);
394
 
 
395
 
  friend std::ostream& operator<<(std::ostream& output, const TableList &list)
396
 
  {
397
 
    output << "TableList:(";
398
 
    output << list.db;
399
 
    output << ", ";
400
 
    output << list.table_name;
401
 
    output << ", ";
402
 
    output << list.alias;
403
 
    output << ", ";
404
 
    output << "is_natural_join:" << list.is_natural_join;
405
 
    output << ", ";
406
 
    output << "is_join_columns_complete:" << list.is_join_columns_complete;
407
 
    output << ", ";
408
 
    output << "straight:" << list.straight;
409
 
    output << ", ";
410
 
    output << "force_index" << list.force_index;
411
 
    output << ", ";
412
 
    output << "ignore_leaves:" << list.ignore_leaves;
413
 
    output << ", ";
414
 
    output << "create:" << list.create;
415
 
    output << ", ";
416
 
    output << "outer_join:" << list.outer_join;
417
 
    output << ", ";
418
 
    output << "nested_join:" << list.nested_join;
419
 
    output << ")";
420
 
 
421
 
    return output;  // for multiple << operators.
422
 
  }
423
 
 
424
 
  void setIsAlias(bool in_is_alias)
425
 
  {
426
 
    is_alias= in_is_alias;
427
 
  }
428
 
 
429
 
  void setIsFqtn(bool in_is_fqtn)
430
 
  {
431
 
    is_fqtn= in_is_fqtn;
432
 
  }
433
 
 
434
 
  void setCreate(bool in_create)
435
 
  {
436
 
    create= in_create;
437
 
  }
438
 
 
439
 
  void setInternalTmpTable(bool in_internal_tmp_table)
440
 
  {
441
 
    internal_tmp_table= in_internal_tmp_table;
442
 
  }
443
 
 
444
 
  void setDbType(plugin::StorageEngine *in_db_type)
445
 
  {
446
 
    db_type= in_db_type;
447
 
  }
448
 
 
449
 
  void setJoinList(List<TableList> *in_join_list)
450
 
  {
451
 
    join_list= in_join_list;
452
 
  }
453
 
 
454
 
  void setEmbedding(TableList *in_embedding)
455
 
  {
456
 
    embedding= in_embedding;
457
 
  }
458
 
 
459
 
  void setNestedJoin(NestedJoin *in_nested_join)
460
 
  {
461
 
    nested_join= in_nested_join;
462
 
  }
463
 
 
464
 
  void setDepTables(table_map in_dep_tables)
465
 
  {
466
 
    dep_tables= in_dep_tables;
467
 
  }
468
 
 
469
 
  void setOnExprDepTables(table_map in_on_expr_dep_tables)
470
 
  {
471
 
    on_expr_dep_tables= in_on_expr_dep_tables;
472
 
  }
473
 
 
474
 
  bool getIsAlias() const
475
 
  {
476
 
    return is_alias;
477
 
  }
478
 
 
479
 
  bool getIsFqtn() const
480
 
  {
481
 
    return is_fqtn;
482
 
  }
483
 
 
484
 
  bool isCreate() const
485
 
  {
486
 
    return create;
487
 
  }
488
 
 
489
 
  bool getInternalTmpTable() const
490
 
  {
491
 
    return internal_tmp_table;
492
 
  }
493
 
 
494
 
  plugin::StorageEngine *getDbType() const
495
 
  {
496
 
    return db_type;
497
 
  }
498
 
 
499
 
  TableList *getEmbedding() const
500
 
  {
501
 
    return embedding;
502
 
  }
503
 
 
504
 
  List<TableList> *getJoinList() const
505
 
  {
506
 
    return join_list;
507
 
  }
508
 
 
509
 
  NestedJoin *getNestedJoin() const
510
 
  {
511
 
    return nested_join;
512
 
  }
513
 
 
514
 
  table_map getDepTables() const
515
 
  {
516
 
    return dep_tables;
517
 
  }
518
 
 
519
 
  table_map getOnExprDepTables() const
520
 
  {
521
 
    return on_expr_dep_tables;
522
 
  }
523
 
 
524
 
  void unlock_table_name();
525
 
  void unlock_table_names(TableList *last_table= NULL);
526
 
 
527
 
private:
528
 
  table_map dep_tables; ///< tables the table depends on
529
 
  table_map on_expr_dep_tables; ///< tables on expression depends on
530
 
  NestedJoin *nested_join; ///< if the element is a nested join
531
 
  TableList *embedding; ///< nested join containing the table
532
 
  List<TableList> *join_list; ///< join list the table belongs to
533
 
  plugin::StorageEngine *db_type; ///< table_type for handler
534
 
  bool internal_tmp_table;
535
 
 
536
 
  /** true if an alias for this table was specified in the SQL. */
537
 
  bool is_alias;
538
 
 
539
 
  /** 
540
 
   * true if the table is referred to in the statement using a fully
541
 
   * qualified name (<db_name>.<table_name>).
542
 
   */
543
 
  bool is_fqtn;
544
 
 
545
 
  /**
546
 
   * This TableList object corresponds to the table to be created
547
 
   * so it is possible that it does not exist (used in CREATE TABLE
548
 
   * ... SELECT implementation).
549
 
   */
550
 
  bool create;
551
 
 
552
278
};
553
 
 
554
 
void close_thread_tables(Session *session);
555
 
 
556
 
} /* namespace drizzled */
557
 
 
558
 
#endif /* DRIZZLED_TABLE_LIST_H */
 
279
#endif /* DRIZZLED_TMP_TABLE_H */