← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_list.h

  • Committer: clint at fewbar
  • Date: 2009-07-28 01:28:12 UTC
  • mto: (1093.1.33 captain)
  • mto: This revision was merged to the branch mainline in revision 1105.
  • Revision ID: clint@fewbar.com-20090728012812-1b9670cbb45srb4x
implementing Jays suggestions for clearer code

Show diffs side-by-side

added added

removed removed

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