← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_list.h

  • Committer: Monty Taylor
  • Date: 2008-07-24 21:31:56 UTC
  • mto: (236.1.42 codestyle)
  • mto: This revision was merged to the branch mainline in revision 212.
  • Revision ID: monty@inaugust.com-20080724213156-p7f25ldaxvhiq6sh
Moved the includes we use everywhere to to GLOBAL_CPPFLAGS and added AM_CPPFLAGS to an AC_SUBST, so that we could take out the redundant declaration from most fof the Makefiles.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table_list.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 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; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
 
 */
20
 
 
21
 
#ifndef DRIZZLED_TABLE_LIST_H
22
 
#define DRIZZLED_TABLE_LIST_H
23
 
 
24
 
#include <drizzled/table.h>
25
 
 
26
 
namespace drizzled
27
 
{
28
 
 
29
 
class Index_hint;
30
 
class COND_EQUAL;
31
 
class Natural_join_column;
32
 
class select_union;
33
 
class Select_Lex_Unit;
34
 
class Select_Lex;
35
 
class Tmp_Table_Param;
36
 
class Item_subselect;
37
 
class Table;
38
 
 
39
 
namespace plugin
40
 
{
41
 
  class InfoSchemaTable;
42
 
  class StorageEngine;
43
 
}
44
 
 
45
 
struct nested_join_st;
46
 
 
47
 
/**
48
 
 * A Table referenced in the FROM clause.
49
 
 *
50
 
 * These table references can be of several types that correspond to
51
 
 * different SQL elements. Below we list all types of TableLists with
52
 
 * the necessary conditions to determine when a TableList instance
53
 
 * belongs to a certain type.
54
 
 *
55
 
 * 1) table (TableList::view == NULL)
56
 
 *    - base table
57
 
 *    (TableList::derived == NULL)
58
 
 *    - subquery - TableList::table is a temp table
59
 
 *    (TableList::derived != NULL)
60
 
 *    
61
 
 *    @note
62
 
 *
63
 
 *    for schema tables TableList::field_translation may be != NULL
64
 
 *
65
 
 * 2) Was VIEW 
66
 
 * 3) nested table reference (TableList::nested_join != NULL)
67
 
 *     - table sequence - e.g. (t1, t2, t3)
68
 
 *     @todo how to distinguish from a JOIN?
69
 
 *     - general JOIN
70
 
 *     @todo how to distinguish from a table sequence?
71
 
 *     - NATURAL JOIN
72
 
 *     (TableList::natural_join != NULL)
73
 
 *     - JOIN ... USING
74
 
 *     (TableList::join_using_fields != NULL)
75
 
 *     - semi-join
76
 
 */
77
 
class TableList
78
 
{
79
 
public:
80
 
  TableList():
81
 
    next_local(NULL),
82
 
    next_global(NULL),
83
 
    prev_global(NULL),
84
 
    db(NULL),
85
 
    alias(NULL),
86
 
    table_name(NULL),
87
 
    option(NULL),
88
 
    on_expr(NULL),
89
 
    table(NULL),
90
 
    prep_on_expr(NULL),
91
 
    cond_equal(NULL),
92
 
    natural_join(NULL),
93
 
    is_natural_join(false),
94
 
    is_join_columns_complete(false),
95
 
    straight(false),
96
 
    updating(false), 
97
 
    force_index(false),
98
 
    ignore_leaves(false),
99
 
    create(false),
100
 
    join_using_fields(NULL),
101
 
    join_columns(NULL),
102
 
    next_name_resolution_table(NULL),
103
 
    index_hints(NULL),
104
 
    derived_result(NULL),
105
 
    derived(NULL),
106
 
    schema_select_lex(NULL),
107
 
    select_lex(NULL),
108
 
    next_leaf(NULL),
109
 
    outer_join(0),
110
 
    shared(0),
111
 
    i_s_requested_object(0),
112
 
    db_length(0),
113
 
    table_name_length(0),
114
 
    dep_tables(0),
115
 
    on_expr_dep_tables(0),
116
 
    nested_join(NULL),
117
 
    embedding(NULL),
118
 
    join_list(NULL),
119
 
    db_type(NULL),
120
 
    internal_tmp_table(false),
121
 
    is_alias(false),
122
 
    is_fqtn(false),
123
 
    has_db_lookup_value(false),
124
 
    has_table_lookup_value(false)
125
 
  {}
126
 
 
127
 
  /**
128
 
   * List of tables local to a subquery (used by SQL_LIST). Considers
129
 
   * views as leaves (unlike 'next_leaf' below). Created at parse time
130
 
   * in Select_Lex::add_table_to_list() -> table_list.link_in_list().
131
 
   */
132
 
  TableList *next_local;
133
 
 
134
 
  /** link in a global list of all queries tables */
135
 
  TableList *next_global; 
136
 
  TableList **prev_global;
137
 
 
138
 
  char *db;
139
 
  const char *alias;
140
 
  char *table_name;
141
 
  char *option; ///< Used by cache index
142
 
  Item *on_expr; ///< Used with outer join
143
 
  Table *table; ///< opened table
144
 
  /**
145
 
   * The structure of ON expression presented in the member above
146
 
   * can be changed during certain optimizations. This member
147
 
   * contains a snapshot of AND-OR structure of the ON expression
148
 
   * made after permanent transformations of the parse tree, and is
149
 
   * used to restore ON clause before every reexecution of a prepared
150
 
   * statement or stored procedure.
151
 
   */
152
 
  Item *prep_on_expr;
153
 
  COND_EQUAL *cond_equal; ///< Used with outer join
154
 
  /**
155
 
   * During parsing - left operand of NATURAL/USING join where 'this' is
156
 
   * the right operand. After parsing (this->natural_join == this) iff
157
 
   * 'this' represents a NATURAL or USING join operation. Thus after
158
 
   * parsing 'this' is a NATURAL/USING join iff (natural_join != NULL).
159
 
   */
160
 
  TableList *natural_join;
161
 
  /**
162
 
   * True if 'this' represents a nested join that is a NATURAL JOIN.
163
 
   * For one of the operands of 'this', the member 'natural_join' points
164
 
   * to the other operand of 'this'.
165
 
   */
166
 
  bool is_natural_join;
167
 
 
168
 
  /** true if join_columns contains all columns of this table reference. */
169
 
  bool is_join_columns_complete;
170
 
 
171
 
  bool straight; ///< optimize with prev table
172
 
  bool updating; ///< for replicate-do/ignore table
173
 
  bool force_index; ///< prefer index over table scan
174
 
  bool ignore_leaves; ///< preload only non-leaf nodes
175
 
 
176
 
  /**
177
 
   * This TableList object corresponds to the table to be created
178
 
   * so it is possible that it does not exist (used in CREATE TABLE
179
 
   * ... SELECT implementation).
180
 
   */
181
 
  bool create;
182
 
 
183
 
  /** Field names in a USING clause for JOIN ... USING. */
184
 
  List<String> *join_using_fields;
185
 
  /**
186
 
   * Explicitly store the result columns of either a NATURAL/USING join or
187
 
   * an operand of such a join.
188
 
   */
189
 
  List<Natural_join_column> *join_columns;
190
 
 
191
 
  /**
192
 
   * List of nodes in a nested join tree, that should be considered as
193
 
   * leaves with respect to name resolution. The leaves are: views,
194
 
   * top-most nodes representing NATURAL/USING joins, subqueries, and
195
 
   * base tables. All of these TableList instances contain a
196
 
   * materialized list of columns. The list is local to a subquery.
197
 
   */
198
 
  TableList *next_name_resolution_table;
199
 
  /** Index names in a "... JOIN ... USE/IGNORE INDEX ..." clause. */
200
 
  List<Index_hint> *index_hints;
201
 
  /**
202
 
   * select_result for derived table to pass it from table creation to table
203
 
   * filling procedure
204
 
   */
205
 
  select_union *derived_result;
206
 
  Select_Lex_Unit *derived; ///< Select_Lex_Unit of derived table */
207
 
  Select_Lex *schema_select_lex;
208
 
  /** link to select_lex where this table was used */
209
 
  Select_Lex *select_lex;
210
 
  /**
211
 
   * List of all base tables local to a subquery including all view
212
 
   * tables. Unlike 'next_local', this in this list views are *not*
213
 
   * leaves. Created in setup_tables() -> make_leaves_list().
214
 
   */
215
 
  TableList *next_leaf;
216
 
  thr_lock_type lock_type;
217
 
  uint32_t outer_join; ///< Which join type
218
 
  uint32_t shared; ///<Used in multi-upd
219
 
  uint32_t i_s_requested_object;
220
 
  size_t db_length;
221
 
  size_t table_name_length;
222
 
  table_map dep_tables; ///< tables the table depends on
223
 
  table_map on_expr_dep_tables; ///< tables on expression depends on
224
 
  nested_join_st *nested_join; ///< if the element is a nested join
225
 
  TableList *embedding; ///< nested join containing the table
226
 
  List<TableList> *join_list; ///< join list the table belongs to
227
 
  plugin::StorageEngine *db_type; ///< table_type for handler
228
 
  char timestamp_buffer[20]; ///< buffer for timestamp (19+1)
229
 
  bool internal_tmp_table;
230
 
  /** true if an alias for this table was specified in the SQL. */
231
 
  bool is_alias;
232
 
  /** 
233
 
   * true if the table is referred to in the statement using a fully
234
 
   * qualified name (<db_name>.<table_name>).
235
 
   */
236
 
  bool is_fqtn;
237
 
 
238
 
  bool has_db_lookup_value;
239
 
  bool has_table_lookup_value;
240
 
 
241
 
  void set_underlying_merge();
242
 
  bool setup_underlying(Session *session);
243
 
 
244
 
  /**
245
 
   * If you change placeholder(), please check the condition in
246
 
   * check_transactional_lock() too.
247
 
   */
248
 
  bool placeholder();
249
 
  /**
250
 
   * Print table as it should be in join list.
251
 
   * 
252
 
   * @param str   string where table should be printed
253
 
   */
254
 
  void print(Session *session, String *str, enum_query_type query_type);
255
 
  /**
256
 
   * Sets insert_values buffer
257
 
   *
258
 
   * @param[in] memory pool for allocating
259
 
   *
260
 
   * @retval
261
 
   *  false - OK
262
 
   * @retval
263
 
   *  true - out of memory
264
 
   */
265
 
  bool set_insert_values(memory::Root *mem_root);
266
 
  /**
267
 
   * Find underlying base tables (TableList) which represent given
268
 
   * table_to_find (Table)
269
 
   *
270
 
   * @param[in] table to find
271
 
   *
272
 
   * @retval
273
 
   *  NULL if table is not found
274
 
   * @retval
275
 
   *  Pointer to found table reference
276
 
   */
277
 
  TableList *find_underlying_table(Table *table);
278
 
  /**
279
 
   * Retrieve the first (left-most) leaf in a nested join tree with
280
 
   * respect to name resolution.
281
 
   *
282
 
   * @details
283
 
   *
284
 
   * Given that 'this' is a nested table reference, recursively walk
285
 
   * down the left-most children of 'this' until we reach a leaf
286
 
   * table reference with respect to name resolution.
287
 
   *
288
 
   * @retval
289
 
   *  If 'this' is a nested table reference - the left-most child of
290
 
   *  the tree rooted in 'this',
291
 
   *  else return 'this'
292
 
   */
293
 
  TableList *first_leaf_for_name_resolution();
294
 
  /**
295
 
   * Retrieve the last (right-most) leaf in a nested join tree with
296
 
   * respect to name resolution.
297
 
   *
298
 
   * @details
299
 
   *
300
 
   * Given that 'this' is a nested table reference, recursively walk
301
 
   * down the right-most children of 'this' until we reach a leaf
302
 
   * table reference with respect to name resolution.
303
 
   *
304
 
   * @retval
305
 
   *  If 'this' is a nested table reference - the right-most child of
306
 
   *  the tree rooted in 'this',
307
 
   *  else 'this'
308
 
   */
309
 
  TableList *last_leaf_for_name_resolution();
310
 
  /**
311
 
   * Test if this is a leaf with respect to name resolution.
312
 
   *
313
 
   * @details
314
 
   * 
315
 
   * A table reference is a leaf with respect to name resolution if
316
 
   * it is either a leaf node in a nested join tree (table, view,
317
 
   * schema table, subquery), or an inner node that represents a
318
 
   * NATURAL/USING join, or a nested join with materialized join
319
 
   * columns.
320
 
   *
321
 
   * @retval
322
 
   *  true if a leaf, false otherwise.
323
 
   */
324
 
  bool is_leaf_for_name_resolution();
325
 
  inline TableList *top_table()
326
 
  { return this; }
327
 
 
328
 
  /**
329
 
   * Return subselect that contains the FROM list this table is taken from
330
 
   *
331
 
   * @retval
332
 
   *  Subselect item for the subquery that contains the FROM list
333
 
   *  this table is taken from if there is any
334
 
   * @retval
335
 
   *  NULL otherwise
336
 
   */
337
 
  Item_subselect *containing_subselect();
338
 
 
339
 
  /**
340
 
   * Compiles the tagged hints list and fills up st_table::keys_in_use_for_query,
341
 
   * st_table::keys_in_use_for_group_by, st_table::keys_in_use_for_order_by,
342
 
   * st_table::force_index and st_table::covering_keys.
343
 
   *
344
 
   * @param the Table to operate on.
345
 
   *
346
 
   * @details
347
 
   *
348
 
   * The parser collects the index hints for each table in a "tagged list"
349
 
   * (TableList::index_hints). Using the information in this tagged list
350
 
   * this function sets the members Table::keys_in_use_for_query,
351
 
   * Table::keys_in_use_for_group_by, Table::keys_in_use_for_order_by,
352
 
   * Table::force_index and Table::covering_keys.
353
 
   *
354
 
   * Current implementation of the runtime does not allow mixing FORCE INDEX
355
 
   * and USE INDEX, so this is checked here. Then the FORCE INDEX list
356
 
   * (if non-empty) is appended to the USE INDEX list and a flag is set.
357
 
   * 
358
 
   * Multiple hints of the same kind are processed so that each clause
359
 
   * is applied to what is computed in the previous clause.
360
 
   * 
361
 
   * For example:
362
 
   *       USE INDEX (i1) USE INDEX (i2)
363
 
   *    is equivalent to
364
 
   *       USE INDEX (i1,i2)
365
 
   *    and means "consider only i1 and i2".
366
 
   *
367
 
   * Similarly
368
 
   *       USE INDEX () USE INDEX (i1)
369
 
   *    is equivalent to
370
 
   *       USE INDEX (i1)
371
 
   *    and means "consider only the index i1"
372
 
   *
373
 
   * It is OK to have the same index several times, e.g. "USE INDEX (i1,i1)" is
374
 
   * not an error.
375
 
   *
376
 
   * Different kind of hints (USE/FORCE/IGNORE) are processed in the following
377
 
   * order:
378
 
   *    1. All indexes in USE (or FORCE) INDEX are added to the mask.
379
 
   *    2. All IGNORE INDEX
380
 
   *       e.g. "USE INDEX i1, IGNORE INDEX i1, USE INDEX i1" will not use i1 at all
381
 
   *       as if we had "USE INDEX i1, USE INDEX i1, IGNORE INDEX i1".
382
 
   *       As an optimization if there is a covering index, and we have
383
 
   *       IGNORE INDEX FOR GROUP/order_st, and this index is used for the JOIN part,
384
 
   *       then we have to ignore the IGNORE INDEX FROM GROUP/order_st.
385
 
   *
386
 
   * @retval
387
 
   *   false no errors found
388
 
   * @retval
389
 
   *   true found and reported an error.
390
 
   */
391
 
  bool process_index_hints(Table *table);
392
 
  /**
393
 
   * Creates a table definition cache key for this table entry.
394
 
   *
395
 
   * @param[out] Create key here (must be of size MAX_DBKEY_LENGTH)
396
 
   *
397
 
   * @note
398
 
   *
399
 
   * The table cache_key is created from:
400
 
   *   db_name + \0
401
 
   *   table_name + \0
402
 
   *
403
 
   * if the table is a tmp table, we add the following to make each tmp table
404
 
   * unique on the slave:
405
 
   *
406
 
   * 4 bytes for master thread id
407
 
   * 4 bytes pseudo thread id
408
 
   *
409
 
   * @retval
410
 
   *  Length of key
411
 
   */
412
 
  uint32_t create_table_def_key(char *key);
413
 
};
414
 
 
415
 
void close_thread_tables(Session *session);
416
 
 
417
 
} /* namespace drizzled */
418
 
 
419
 
#endif /* DRIZZLED_TABLE_LIST_H */