1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
|
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
*
* Copyright (C) 2008 Sun Microsystems
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef DRIZZLED_TABLE_LIST_H
#define DRIZZLED_TABLE_LIST_H
/*
Table reference in the FROM clause.
These table references can be of several types that correspond to
different SQL elements. Below we list all types of TableLists with
the necessary conditions to determine when a TableList instance
belongs to a certain type.
1) table (TableList::view == NULL)
- base table
(TableList::derived == NULL)
- subquery - TableList::table is a temp table
(TableList::derived != NULL)
- information schema table
(TableList::schema_table != NULL)
NOTICE: for schema tables TableList::field_translation may be != NULL
2) Was VIEW
3) nested table reference (TableList::nested_join != NULL)
- table sequence - e.g. (t1, t2, t3)
TODO: how to distinguish from a JOIN?
- general JOIN
TODO: how to distinguish from a table sequence?
- NATURAL JOIN
(TableList::natural_join != NULL)
- JOIN ... USING
(TableList::join_using_fields != NULL)
- semi-join
;
*/
#include <drizzled/table.h>
class Index_hint;
class COND_EQUAL;
class Natural_join_column;
class select_union;
class Select_Lex_Unit;
class ST_SCHEMA_TABLE;
class Select_Lex;
class Tmp_Table_Param;
class Item_subselect;
class Table;
struct nested_join_st;
class TableList
{
public:
TableList() {} /* Remove gcc warning */
/**
Prepare TableList that consists of one table instance to use in
simple_open_and_lock_tables
*/
inline void init_one_table(const char *db_name_arg,
const char *table_name_arg,
enum thr_lock_type lock_type_arg)
{
memset(this, 0, sizeof(*this));
db= (char*) db_name_arg;
table_name= alias= (char*) table_name_arg;
lock_type= lock_type_arg;
}
/*
List of tables local to a subquery (used by SQL_LIST). Considers
views as leaves (unlike 'next_leaf' below). Created at parse time
in Select_Lex::add_table_to_list() -> table_list.link_in_list().
*/
TableList *next_local;
/* link in a global list of all queries tables */
TableList *next_global, **prev_global;
char *db, *alias, *table_name, *schema_table_name;
char *option; /* Used by cache index */
Item *on_expr; /* Used with outer join */
Item *sj_on_expr;
/*
(Valid only for semi-join nests) Bitmap of tables that are within the
semi-join (this is different from bitmap of all nest's children because
tables that were pulled out of the semi-join nest remain listed as
nest's children).
*/
table_map sj_inner_tables;
/* Number of IN-compared expressions */
uint32_t sj_in_exprs;
/*
The structure of ON expression presented in the member above
can be changed during certain optimizations. This member
contains a snapshot of AND-OR structure of the ON expression
made after permanent transformations of the parse tree, and is
used to restore ON clause before every reexecution of a prepared
statement or stored procedure.
*/
Item *prep_on_expr;
COND_EQUAL *cond_equal; /* Used with outer join */
/*
During parsing - left operand of NATURAL/USING join where 'this' is
the right operand. After parsing (this->natural_join == this) iff
'this' represents a NATURAL or USING join operation. Thus after
parsing 'this' is a NATURAL/USING join iff (natural_join != NULL).
*/
TableList *natural_join;
/*
True if 'this' represents a nested join that is a NATURAL JOIN.
For one of the operands of 'this', the member 'natural_join' points
to the other operand of 'this'.
*/
bool is_natural_join;
/* Field names in a USING clause for JOIN ... USING. */
List<String> *join_using_fields;
/*
Explicitly store the result columns of either a NATURAL/USING join or
an operand of such a join.
*/
List<Natural_join_column> *join_columns;
/* true if join_columns contains all columns of this table reference. */
bool is_join_columns_complete;
/*
List of nodes in a nested join tree, that should be considered as
leaves with respect to name resolution. The leaves are: views,
top-most nodes representing NATURAL/USING joins, subqueries, and
base tables. All of these TableList instances contain a
materialized list of columns. The list is local to a subquery.
*/
TableList *next_name_resolution_table;
/* Index names in a "... JOIN ... USE/IGNORE INDEX ..." clause. */
List<Index_hint> *index_hints;
Table *table; /* opened table */
uint32_t table_id; /* table id (from binlog) for opened table */
/*
select_result for derived table to pass it from table creation to table
filling procedure
*/
select_union *derived_result;
/*
Reference from aux_tables to local list entry of main select of
multi-delete statement:
delete t1 from t2,t1 where t1.a<'B' and t2.b=t1.b;
here it will be reference of first occurrence of t1 to second (as you
can see this lists can't be merged)
*/
TableList *correspondent_table;
Select_Lex_Unit *derived; /* Select_Lex_Unit of derived table */
ST_SCHEMA_TABLE *schema_table; /* Information_schema table */
Select_Lex *schema_select_lex;
/*
True when the view field translation table is used to convert
schema table fields for backwards compatibility with SHOW command.
*/
bool schema_table_reformed;
Tmp_Table_Param *schema_table_param;
/* link to select_lex where this table was used */
Select_Lex *select_lex;
/*
List (based on next_local) of underlying tables of this view. I.e. it
does not include the tables of subqueries used in the view. Is set only
for merged views.
*/
TableList *merge_underlying_list;
/*
List of all base tables local to a subquery including all view
tables. Unlike 'next_local', this in this list views are *not*
leaves. Created in setup_tables() -> make_leaves_list().
*/
TableList *next_leaf;
thr_lock_type lock_type;
uint outer_join; /* Which join type */
uint shared; /* Used in multi-upd */
size_t db_length;
size_t table_name_length;
bool straight; /* optimize with prev table */
bool updating; /* for replicate-do/ignore table */
bool force_index; /* prefer index over table scan */
bool ignore_leaves; /* preload only non-leaf nodes */
table_map dep_tables; /* tables the table depends on */
table_map on_expr_dep_tables; /* tables on expression depends on */
nested_join_st *nested_join; /* if the element is a nested join */
TableList *embedding; /* nested join containing the table */
List<TableList> *join_list;/* join list the table belongs to */
bool cacheable_table; /* stop PS caching */
StorageEngine *db_type; /* table_type for handler */
char timestamp_buffer[20]; /* buffer for timestamp (19+1) */
/*
This TableList object corresponds to the table to be created
so it is possible that it does not exist (used in CREATE TABLE
... SELECT implementation).
*/
bool create;
/* For transactional locking. */
int lock_timeout; /* NOWAIT or WAIT [X] */
bool lock_transactional; /* If transactional lock requested. */
bool internal_tmp_table;
/** true if an alias for this table was specified in the SQL. */
bool is_alias;
/** true if the table is referred to in the statement using a fully
qualified name (<db_name>.<table_name>).
*/
bool is_fqtn;
uint32_t i_s_requested_object;
bool has_db_lookup_value;
bool has_table_lookup_value;
uint32_t table_open_method;
enum enum_schema_table_state schema_table_state;
void set_underlying_merge();
bool setup_underlying(Session *session);
void cleanup_items();
/*
If you change placeholder(), please check the condition in
check_transactional_lock() too.
*/
bool placeholder();
void print(Session *session, String *str, enum_query_type query_type);
bool set_insert_values(MEM_ROOT *mem_root);
TableList *find_underlying_table(Table *table);
TableList *first_leaf_for_name_resolution();
TableList *last_leaf_for_name_resolution();
bool is_leaf_for_name_resolution();
inline TableList *top_table()
{ return this; }
/*
Cleanup for re-execution in a prepared statement or a stored
procedure.
*/
void reinit_before_use(Session *session);
Item_subselect *containing_subselect();
/*
Compiles the tagged hints list and fills up st_table::keys_in_use_for_query,
st_table::keys_in_use_for_group_by, st_table::keys_in_use_for_order_by,
st_table::force_index and st_table::covering_keys.
*/
bool process_index_hints(Table *table);
};
void close_thread_tables(Session *session);
#endif /* DRIZZLED_TABLE_LIST_H */
|