1
/* Copyright (C) 2000-2006 MySQL AB
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.
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.
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 */
17
/* Structs that defines the TABLE */
19
class Item; /* Needed by ORDER */
21
class st_select_lex_unit;
24
class Security_context;
26
/*************************************************************************/
28
/* Order clause list element */
30
typedef struct st_order {
31
struct st_order *next;
32
Item **item; /* Point at item in select fields */
33
Item *item_ptr; /* Storage for initial item */
34
Item **item_copy; /* For SPs; the original item ptr */
35
int counter; /* position in SELECT list, correct
36
only if counter_used is true*/
37
bool asc; /* true if ascending */
38
bool free_me; /* true if item isn't shared */
39
bool in_field_list; /* true if in select field list */
40
bool counter_used; /* parameter was counter of columns */
41
Field *field; /* If tmp-table group */
42
char *buff; /* If tmp-table group */
43
table_map used, depend_map;
48
NO_TMP_TABLE, NON_TRANSACTIONAL_TMP_TABLE, TRANSACTIONAL_TMP_TABLE,
49
INTERNAL_TMP_TABLE, SYSTEM_TMP_TABLE, TMP_TABLE_FRM_FILE_ONLY
58
frm_type_enum mysql_frm_type(THD *thd, char *path, enum legacy_db_type *dbt);
61
enum release_type { RELEASE_NORMAL, RELEASE_WAIT_FOR_DROP };
63
typedef struct st_filesort_info
65
IO_CACHE *io_cache; /* If sorted through filesort */
66
uchar **sort_keys; /* Buffer for sorting keys */
67
uchar *buffpek; /* Buffer for buffpek structures */
68
uint buffpek_len; /* Max number of buffpeks in the buffer */
69
uchar *addon_buf; /* Pointer to a buffer if sorted with fields */
70
size_t addon_length; /* Length of the buffer */
71
struct st_sort_addon_field *addon_field; /* Pointer to the fields info */
72
void (*unpack)(struct st_sort_addon_field *, uchar *); /* To unpack back */
73
uchar *record_pointers; /* If sorted in memory */
74
ha_rows found_records; /* How many records in sort */
79
Values in this enum are used to indicate how a tables TIMESTAMP field
80
should be treated. It can be set to the current timestamp on insert or
82
WARNING: The values are used for bit operations. If you change the
83
enum, you must keep the bitwise relation of the values. For example:
84
(int) TIMESTAMP_AUTO_SET_ON_BOTH must be equal to
85
(int) TIMESTAMP_AUTO_SET_ON_INSERT | (int) TIMESTAMP_AUTO_SET_ON_UPDATE.
86
We use an enum here so that the debugger can display the value names.
88
enum timestamp_auto_set_type
90
TIMESTAMP_NO_AUTO_SET= 0, TIMESTAMP_AUTO_SET_ON_INSERT= 1,
91
TIMESTAMP_AUTO_SET_ON_UPDATE= 2, TIMESTAMP_AUTO_SET_ON_BOTH= 3
93
#define clear_timestamp_auto_bits(_target_, _bits_) \
94
(_target_)= (enum timestamp_auto_set_type)((int)(_target_) & ~(int)(_bits_))
96
class Field_timestamp;
98
class Table_triggers_list;
101
Category of table found in the table share.
103
enum enum_table_category
108
TABLE_UNKNOWN_CATEGORY=0,
112
The table is visible only in the session.
114
- FLUSH TABLES WITH READ LOCK
115
- SET GLOBAL READ_ONLY = ON
116
do not apply to this table.
117
Note that LOCK TABLE t FOR READ/WRITE
118
can be used on temporary tables.
119
Temporary tables are not part of the table cache.
121
TABLE_CATEGORY_TEMPORARY=1,
125
These tables do honor:
126
- LOCK TABLE t FOR READ/WRITE
127
- FLUSH TABLES WITH READ LOCK
128
- SET GLOBAL READ_ONLY = ON
129
User tables are cached in the table cache.
131
TABLE_CATEGORY_USER=2,
134
System table, maintained by the server.
135
These tables do honor:
136
- LOCK TABLE t FOR READ/WRITE
137
- FLUSH TABLES WITH READ LOCK
138
- SET GLOBAL READ_ONLY = ON
139
Typically, writes to system tables are performed by
140
the server implementation, not explicitly be a user.
141
System tables are cached in the table cache.
143
TABLE_CATEGORY_SYSTEM=3,
146
Information schema tables.
147
These tables are an interface provided by the system
148
to inspect the system metadata.
149
These tables do *not* honor:
150
- LOCK TABLE t FOR READ/WRITE
151
- FLUSH TABLES WITH READ LOCK
152
- SET GLOBAL READ_ONLY = ON
153
as there is no point in locking explicitely
154
an INFORMATION_SCHEMA table.
155
Nothing is directly written to information schema tables.
156
Note that this value is not used currently,
157
since information schema tables are not shared,
158
but implemented as session specific temporary tables.
161
TODO: Fixing the performance issues of I_S will lead
162
to I_S tables in the table cache, which should use
165
TABLE_CATEGORY_INFORMATION=4,
167
typedef enum enum_table_category TABLE_CATEGORY;
169
TABLE_CATEGORY get_table_category(const LEX_STRING *db,
170
const LEX_STRING *name);
173
This structure is shared between different table objects. There is one
174
instance of table share per one table in the database.
177
typedef struct st_table_share
179
st_table_share() {} /* Remove gcc warning */
181
/** Category of this table. */
182
TABLE_CATEGORY table_category;
184
/* hash of field names (contains pointers to elements of field array) */
185
HASH name_hash; /* hash of field names */
187
TYPELIB keynames; /* Pointers to keynames */
188
TYPELIB fieldnames; /* Pointer to fieldnames */
189
TYPELIB *intervals; /* pointer to interval info */
190
pthread_mutex_t mutex; /* For locking the share */
191
pthread_cond_t cond; /* To signal that share is ready */
192
struct st_table_share *next, /* Link to unused shares */
195
/* The following is copied to each TABLE on OPEN */
197
Field **found_next_number_field;
198
Field *timestamp_field; /* Used only during open */
199
KEY *key_info; /* data of keys in database */
200
uint *blob_field; /* Index to blobs in Field arrray*/
202
uchar *default_values; /* row with default values */
203
LEX_STRING comment; /* Comment about table */
204
CHARSET_INFO *table_charset; /* Default charset of string fields */
208
Key which is used for looking-up table in table cache and in the list
209
of thread's temporary tables. Has the form of:
210
"database_name\0table_name\0" + optional part for temporary tables.
212
Note that all three 'table_cache_key', 'db' and 'table_name' members
213
must be set (and be non-zero) for tables in table cache. They also
214
should correspond to each other.
215
To ensure this one can use set_table_cache() methods.
217
LEX_STRING table_cache_key;
218
LEX_STRING db; /* Pointer to db */
219
LEX_STRING table_name; /* Table name (for open) */
220
LEX_STRING path; /* Path to .frm file (from datadir) */
221
LEX_STRING normalized_path; /* unpack_filename(path) */
222
LEX_STRING connect_string;
225
Set of keys in use, implemented as a Bitmap.
226
Excludes keys disabled by ALTER TABLE ... DISABLE KEYS.
229
key_map keys_for_keyread;
230
ha_rows min_rows, max_rows; /* create information */
231
ulong avg_row_length; /* create information */
232
ulong version, mysql_version;
233
ulong timestamp_offset; /* Set to offset+1 of record */
234
ulong reclength; /* Recordlength */
236
plugin_ref db_plugin; /* storage engine plugin */
237
inline handlerton *db_type() const /* table_type for handler */
239
// DBUG_ASSERT(db_plugin);
240
return db_plugin ? plugin_data(db_plugin, handlerton*) : NULL;
242
enum row_type row_type; /* How rows are stored */
243
enum ha_storage_media default_storage_media;
245
enum tmp_table_type tmp_table;
246
enum ha_choice transactional;
247
enum ha_choice page_checksum;
249
uint ref_count; /* How many TABLE objects uses this */
250
uint open_count; /* Number of tables in open list */
251
uint blob_ptr_size; /* 4 or 8 */
252
uint key_block_size; /* create key_block_size, if used */
253
uint null_bytes, last_null_bit_pos;
254
uint fields; /* Number of fields */
255
uint rec_buff_length; /* Size of table->record[] buffer */
256
uint keys, key_parts;
257
uint max_key_length, max_unique_length, total_key_length;
258
uint uniques; /* Number of UNIQUE index */
259
uint null_fields; /* number of null fields */
260
uint blob_fields; /* number of blob fields */
261
uint timestamp_field_offset; /* Field number for timestamp field */
262
uint varchar_fields; /* number of varchar fields */
263
uint db_create_options; /* Create options from database */
264
uint db_options_in_use; /* Options in use */
265
uint db_record_offset; /* if HA_REC_IN_SEQ */
266
uint raid_type, raid_chunks;
267
uint rowid_field_offset; /* Field_nr +1 to rowid field */
268
/* Index of auto-updated TIMESTAMP field in field array */
270
uint next_number_index; /* autoincrement key number */
271
uint next_number_key_offset; /* autoinc keypart offset in a key */
272
uint next_number_keypart; /* autoinc keypart number in a key */
273
uint error, open_errno, errarg; /* error from open_table_def() */
274
uint column_bitmap_size;
276
bool null_field_first;
277
bool system; /* Set if system table (one record) */
278
bool crypted; /* If .frm file is crypted */
279
bool db_low_byte_first; /* Portable row format */
281
bool name_lock, replace_with_name_lock;
282
bool waiting_on_cond; /* Protection against free */
283
ulong table_map_id; /* for row-based replication */
284
uint64_t table_map_version;
287
Cache for row-based replication table share checks that does not
288
need to be repeated. Possible values are: -1 when cache value is
289
not calculated yet, 0 when table *shall not* be replicated, 1 when
290
table *may* be replicated.
292
int cached_row_logging_check;
295
Set share's table cache key and update its db and table name appropriately.
298
set_table_cache_key()
299
key_buff Buffer with already built table cache key to be
300
referenced from share.
301
key_length Key length.
304
Since 'key_buff' buffer will be referenced from share it should has same
305
life-time as share itself.
306
This method automatically ensures that TABLE_SHARE::table_name/db have
307
appropriate values by using table cache key as their source.
310
void set_table_cache_key(char *key_buff, uint key_length)
312
table_cache_key.str= key_buff;
313
table_cache_key.length= key_length;
315
Let us use the fact that the key is "db/0/table_name/0" + optional
316
part for temporary tables.
318
db.str= table_cache_key.str;
319
db.length= strlen(db.str);
320
table_name.str= db.str + db.length + 1;
321
table_name.length= strlen(table_name.str);
326
Set share's table cache key and update its db and table name appropriately.
329
set_table_cache_key()
330
key_buff Buffer to be used as storage for table cache key
331
(should be at least key_length bytes).
332
key Value for table cache key.
333
key_length Key length.
336
Since 'key_buff' buffer will be used as storage for table cache key
337
it should has same life-time as share itself.
340
void set_table_cache_key(char *key_buff, const char *key, uint key_length)
342
memcpy(key_buff, key, key_length);
343
set_table_cache_key(key_buff, key_length);
346
inline bool honor_global_locks()
348
return ((table_category == TABLE_CATEGORY_USER)
349
|| (table_category == TABLE_CATEGORY_SYSTEM));
352
inline ulong get_table_def_version()
360
extern ulong refresh_version;
362
/* Information for one open table */
371
st_table() {} /* Remove gcc warning */
375
struct st_table *next, *prev;
377
THD *in_use; /* Which thread uses this */
378
Field **field; /* Pointer to fields */
380
uchar *record[2]; /* Pointer to records */
381
uchar *write_row_record; /* Used as optimisation in
383
uchar *insert_values; /* used by INSERT ... UPDATE */
385
Map of keys that can be used to retrieve all data from this table
386
needed by the query without reading the row.
388
key_map covering_keys;
389
key_map quick_keys, merge_keys;
391
A set of keys that can be used in the query that references this
394
All indexes disabled on the table's TABLE_SHARE (see TABLE::s) will be
395
subtracted from this set upon instantiation. Thus for any TABLE t it holds
396
that t.keys_in_use_for_query is a subset of t.s.keys_in_use. Generally we
397
must not introduce any new keys here (see setup_tables).
399
The set is implemented as a bitmap.
401
key_map keys_in_use_for_query;
402
/* Map of keys that can be used to calculate GROUP BY without sorting */
403
key_map keys_in_use_for_group_by;
404
/* Map of keys that can be used to calculate ORDER BY without sorting */
405
key_map keys_in_use_for_order_by;
406
KEY *key_info; /* data of keys in database */
408
Field *next_number_field; /* Set if next_number is activated */
409
Field *found_next_number_field; /* Set on open */
410
Field_timestamp *timestamp_field;
412
/* Table's triggers, 0 if there are no of them */
413
Table_triggers_list *triggers;
414
TABLE_LIST *pos_in_table_list;/* Element referring to this table */
416
const char *alias; /* alias or table name */
418
my_bitmap_map *bitmap_init_value;
419
MY_BITMAP def_read_set, def_write_set, tmp_set; /* containers */
420
MY_BITMAP *read_set, *write_set; /* Active column sets */
422
The ID of the query that opened and is using this table. Has different
423
meanings depending on the table type.
427
table->query_id is set to thd->query_id for the duration of a statement
428
and is reset to 0 once it is closed by the same statement. A non-zero
429
table->query_id means that a statement is using the table even if it's
430
not the current statement (table is in use by some outer statement).
432
Non-temporary tables:
434
Under pre-locked or LOCK TABLES mode: query_id is set to thd->query_id
435
for the duration of a statement and is reset to 0 once it is closed by
436
the same statement. A non-zero query_id is used to control which tables
437
in the list of pre-opened and locked tables are actually being used.
442
For each key that has quick_keys.is_set(key) == TRUE: estimate of #records
443
and max #key parts that range access would use.
445
ha_rows quick_rows[MAX_KEY];
447
/* Bitmaps of key parts that =const for the entire join. */
448
key_part_map const_key_parts[MAX_KEY];
450
uint quick_key_parts[MAX_KEY];
451
uint quick_n_ranges[MAX_KEY];
454
Estimate of number of records that satisfy SARGable part of the table
455
condition, or table->file->records if no SARGable condition could be
457
This value is used by join optimizer as an estimate of number of records
458
that will pass the table condition (condition that depends on fields of
459
this table and constants)
461
ha_rows quick_condition_rows;
464
If this table has TIMESTAMP field with auto-set property (pointed by
465
timestamp_field member) then this variable indicates during which
466
operations (insert only/on update/in both cases) we should set this
467
field to current timestamp. If there are no such field in this table
468
or we should not automatically set its value during execution of current
469
statement then the variable contains TIMESTAMP_NO_AUTO_SET (i.e. 0).
471
Value of this variable is set for each statement in open_table() and
472
if needed cleared later in statement processing code (see mysql_update()
475
timestamp_auto_set_type timestamp_field_type;
476
table_map map; /* ID bit of table (1,2,4,8,16...) */
478
uint lock_position; /* Position in MYSQL_LOCK.table */
479
uint lock_data_start; /* Start pos. in MYSQL_LOCK.locks */
480
uint lock_count; /* Number of locks */
481
uint tablenr,used_fields;
482
uint temp_pool_slot; /* Used by intern temp tables */
483
uint status; /* What's in record[0] */
484
uint db_stat; /* mode of file as in handler.h */
485
/* number of select if it is derived table */
486
uint derived_select_number;
487
int current_lock; /* Type of lock on table */
488
my_bool copy_blobs; /* copy_blobs when storing */
491
0 or JOIN_TYPE_{LEFT|RIGHT}. Currently this is only compared to 0.
492
If maybe_null !=0, this table is inner w.r.t. some outer join operation,
493
and null_row may be true.
497
If true, the current table row is considered to have all columns set to
498
NULL, including columns declared as "not null" (see maybe_null).
503
TODO: Each of the following flags take up 8 bits. They can just as easily
504
be put into one single unsigned long and instead of taking up 18
505
bytes, it would take up 4.
508
my_bool distinct,const_table,no_rows;
509
my_bool key_read, no_keyread;
511
Placeholder for an open table which prevents other connections
512
from taking name-locks on this table. Typically used with
513
TABLE_SHARE::version member to take an exclusive name-lock on
514
this table name -- a name lock that not only prevents other
515
threads from opening the table, but also blocks other name
516
locks. This is achieved by:
517
- setting open_placeholder to 1 - this will block other name
518
locks, as wait_for_locked_table_name will be forced to wait,
519
see table_is_used for details.
520
- setting version to 0 - this will force other threads to close
521
the instance of this table and wait (this is the same approach
522
as used for usual name locks).
523
An exclusively name-locked table currently can have no handler
524
object associated with it (db_stat is always 0), but please do
527
my_bool open_placeholder;
528
my_bool locked_by_logger;
529
my_bool no_replicate;
530
my_bool locked_by_name;
531
my_bool fulltext_searched;
533
/* To signal that the table is associated with a HANDLER statement */
534
my_bool open_by_handler;
536
To indicate that a non-null value of the auto_increment field
537
was provided by the user or retrieved from the current record.
538
Used only in the MODE_NO_AUTO_VALUE_ON_ZERO mode.
540
my_bool auto_increment_field_not_null;
541
my_bool insert_or_update; /* Can be used by the handler */
542
my_bool alias_name_used; /* true if table_name is alias */
543
my_bool get_fields_in_item_tree; /* Signal to fix_field */
545
REGINFO reginfo; /* field connections */
549
bool fill_item_list(List<Item> *item_list) const;
550
void reset_item_list(List<Item> *item_list) const;
551
void clear_column_bitmaps(void);
552
void prepare_for_position(void);
553
void mark_columns_used_by_index_no_reset(uint index, MY_BITMAP *map);
554
void mark_columns_used_by_index(uint index);
555
void restore_column_maps_after_mark_index();
556
void mark_auto_increment_column(void);
557
void mark_columns_needed_for_update(void);
558
void mark_columns_needed_for_delete(void);
559
void mark_columns_needed_for_insert(void);
560
inline void column_bitmaps_set(MY_BITMAP *read_set_arg,
561
MY_BITMAP *write_set_arg)
563
read_set= read_set_arg;
564
write_set= write_set_arg;
566
file->column_bitmaps_signal();
568
inline void column_bitmaps_set_no_signal(MY_BITMAP *read_set_arg,
569
MY_BITMAP *write_set_arg)
571
read_set= read_set_arg;
572
write_set= write_set_arg;
574
inline void use_all_columns()
576
column_bitmaps_set(&s->all_set, &s->all_set);
578
inline void default_column_bitmaps()
580
read_set= &def_read_set;
581
write_set= &def_write_set;
583
/* Is table open or should be treated as such by name-locking? */
584
inline bool is_name_opened() { return db_stat || open_placeholder; }
586
Is this instance of the table should be reopen or represents a name-lock?
588
inline bool needs_reopen_or_name_lock()
589
{ return s->version != refresh_version; }
592
enum enum_schema_table_state
595
PROCESSED_BY_CREATE_SORT_INDEX,
596
PROCESSED_BY_JOIN_EXEC
599
typedef struct st_foreign_key_info
601
LEX_STRING *forein_id;
602
LEX_STRING *referenced_db;
603
LEX_STRING *referenced_table;
604
LEX_STRING *update_method;
605
LEX_STRING *delete_method;
606
LEX_STRING *referenced_key_name;
607
List<LEX_STRING> foreign_fields;
608
List<LEX_STRING> referenced_fields;
612
Make sure that the order of schema_tables and enum_schema_tables are the same.
615
enum enum_schema_tables
619
SCH_COLLATION_CHARACTER_SET_APPLICABILITY,
622
SCH_GLOBAL_VARIABLES,
623
SCH_KEY_COLUMN_USAGE,
627
SCH_REFERENTIAL_CONSTRAINTS,
630
SCH_SESSION_VARIABLES,
634
SCH_TABLE_CONSTRAINTS,
640
#define MY_I_S_MAYBE_NULL 1
641
#define MY_I_S_UNSIGNED 2
644
#define SKIP_OPEN_TABLE 0 // do not open table
645
#define OPEN_FRM_ONLY 1 // open FRM file only
646
#define OPEN_FULL_TABLE 2 // open FRM,MYD, MYI files
648
typedef struct st_field_info
651
This is used as column name.
653
const char* field_name;
655
For string-type columns, this is the maximum number of
656
characters. Otherwise, it is the 'display-length' for the column.
660
This denotes data type for the column. For the most part, there seems to
661
be one entry in the enum for each SQL data type, although there seem to
662
be a number of additional entries in the enum.
664
enum enum_field_types field_type;
667
This is used to set column attributes. By default, columns are @c NOT
668
@c NULL and @c SIGNED, and you can deviate from the default
669
by setting the appopriate flags. You can use either one of the flags
670
@c MY_I_S_MAYBE_NULL and @cMY_I_S_UNSIGNED or
671
combine them using the bitwise or operator @c |. Both flags are
674
uint field_flags; // Field atributes(maybe_null, signed, unsigned etc.)
675
const char* old_name;
677
This should be one of @c SKIP_OPEN_TABLE,
678
@c OPEN_FRM_ONLY or @c OPEN_FULL_TABLE.
685
typedef class Item COND;
687
typedef struct st_schema_table
689
const char* table_name;
690
ST_FIELD_INFO *fields_info;
691
/* Create information_schema table */
692
TABLE *(*create_table) (THD *thd, TABLE_LIST *table_list);
693
/* Fill table with data */
694
int (*fill_table) (THD *thd, TABLE_LIST *tables, COND *cond);
695
/* Handle fileds for old SHOW */
696
int (*old_format) (THD *thd, struct st_schema_table *schema_table);
697
int (*process_table) (THD *thd, TABLE_LIST *tables, TABLE *table,
698
bool res, LEX_STRING *db_name, LEX_STRING *table_name);
699
int idx_field1, idx_field2;
701
uint i_s_requested_object; /* the object we need to open(TABLE | VIEW) */
705
#define JOIN_TYPE_LEFT 1
706
#define JOIN_TYPE_RIGHT 2
710
class TMP_TABLE_PARAM;
712
Item *create_view_field(THD *thd, TABLE_LIST *view, Item **field_ref,
715
struct Field_translator
723
Column reference of a NATURAL/USING join. Since column references in
724
joins can be both from views and stored tables, may point to either a
725
Field (for tables), or a Field_translator (for views).
728
class Natural_join_column: public Sql_alloc
731
Field_translator *view_field; /* Column reference of merge view. */
732
Field *table_field; /* Column reference of table or temp view. */
733
TABLE_LIST *table_ref; /* Original base table/view reference. */
735
True if a common join column of two NATURAL/USING join operands. Notice
736
that when we have a hierarchy of nested NATURAL/USING joins, a column can
737
be common at some level of nesting but it may not be common at higher
738
levels of nesting. Thus this flag may change depending on at which level
739
we are looking at some column.
743
Natural_join_column(Field_translator *field_param, TABLE_LIST *tab);
744
Natural_join_column(Field *field_param, TABLE_LIST *tab);
746
Item *create_item(THD *thd);
748
const char *table_name();
749
const char *db_name();
754
Table reference in the FROM clause.
756
These table references can be of several types that correspond to
757
different SQL elements. Below we list all types of TABLE_LISTs with
758
the necessary conditions to determine when a TABLE_LIST instance
759
belongs to a certain type.
761
1) table (TABLE_LIST::view == NULL)
763
(TABLE_LIST::derived == NULL)
764
- subquery - TABLE_LIST::table is a temp table
765
(TABLE_LIST::derived != NULL)
766
- information schema table
767
(TABLE_LIST::schema_table != NULL)
768
NOTICE: for schema tables TABLE_LIST::field_translation may be != NULL
769
2) view (TABLE_LIST::view != NULL)
770
- merge (TABLE_LIST::effective_algorithm == VIEW_ALGORITHM_MERGE)
771
also (TABLE_LIST::field_translation != NULL)
772
- tmptable (TABLE_LIST::effective_algorithm == VIEW_ALGORITHM_TMPTABLE)
773
also (TABLE_LIST::field_translation == NULL)
774
3) nested table reference (TABLE_LIST::nested_join != NULL)
775
- table sequence - e.g. (t1, t2, t3)
776
TODO: how to distinguish from a JOIN?
778
TODO: how to distinguish from a table sequence?
780
(TABLE_LIST::natural_join != NULL)
782
(TABLE_LIST::join_using_fields != NULL)
790
TABLE_LIST() {} /* Remove gcc warning */
793
Prepare TABLE_LIST that consists of one table instance to use in
794
simple_open_and_lock_tables
796
inline void init_one_table(const char *db_name_arg,
797
const char *table_name_arg,
798
enum thr_lock_type lock_type_arg)
800
bzero((char*) this, sizeof(*this));
801
db= (char*) db_name_arg;
802
table_name= alias= (char*) table_name_arg;
803
lock_type= lock_type_arg;
807
List of tables local to a subquery (used by SQL_LIST). Considers
808
views as leaves (unlike 'next_leaf' below). Created at parse time
809
in st_select_lex::add_table_to_list() -> table_list.link_in_list().
811
TABLE_LIST *next_local;
812
/* link in a global list of all queries tables */
813
TABLE_LIST *next_global, **prev_global;
814
char *db, *alias, *table_name, *schema_table_name;
815
char *option; /* Used by cache index */
816
Item *on_expr; /* Used with outer join */
819
(Valid only for semi-join nests) Bitmap of tables that are within the
820
semi-join (this is different from bitmap of all nest's children because
821
tables that were pulled out of the semi-join nest remain listed as
824
table_map sj_inner_tables;
825
/* Number of IN-compared expressions */
828
The structure of ON expression presented in the member above
829
can be changed during certain optimizations. This member
830
contains a snapshot of AND-OR structure of the ON expression
831
made after permanent transformations of the parse tree, and is
832
used to restore ON clause before every reexecution of a prepared
833
statement or stored procedure.
836
COND_EQUAL *cond_equal; /* Used with outer join */
838
During parsing - left operand of NATURAL/USING join where 'this' is
839
the right operand. After parsing (this->natural_join == this) iff
840
'this' represents a NATURAL or USING join operation. Thus after
841
parsing 'this' is a NATURAL/USING join iff (natural_join != NULL).
843
TABLE_LIST *natural_join;
845
True if 'this' represents a nested join that is a NATURAL JOIN.
846
For one of the operands of 'this', the member 'natural_join' points
847
to the other operand of 'this'.
849
bool is_natural_join;
850
/* Field names in a USING clause for JOIN ... USING. */
851
List<String> *join_using_fields;
853
Explicitly store the result columns of either a NATURAL/USING join or
854
an operand of such a join.
856
List<Natural_join_column> *join_columns;
857
/* TRUE if join_columns contains all columns of this table reference. */
858
bool is_join_columns_complete;
861
List of nodes in a nested join tree, that should be considered as
862
leaves with respect to name resolution. The leaves are: views,
863
top-most nodes representing NATURAL/USING joins, subqueries, and
864
base tables. All of these TABLE_LIST instances contain a
865
materialized list of columns. The list is local to a subquery.
867
TABLE_LIST *next_name_resolution_table;
868
/* Index names in a "... JOIN ... USE/IGNORE INDEX ..." clause. */
869
List<Index_hint> *index_hints;
870
TABLE *table; /* opened table */
871
uint table_id; /* table id (from binlog) for opened table */
873
select_result for derived table to pass it from table creation to table
876
select_union *derived_result;
878
Reference from aux_tables to local list entry of main select of
879
multi-delete statement:
880
delete t1 from t2,t1 where t1.a<'B' and t2.b=t1.b;
881
here it will be reference of first occurrence of t1 to second (as you
882
can see this lists can't be merged)
884
TABLE_LIST *correspondent_table;
885
st_select_lex_unit *derived; /* SELECT_LEX_UNIT of derived table */
886
ST_SCHEMA_TABLE *schema_table; /* Information_schema table */
887
st_select_lex *schema_select_lex;
889
True when the view field translation table is used to convert
890
schema table fields for backwards compatibility with SHOW command.
892
bool schema_table_reformed;
893
TMP_TABLE_PARAM *schema_table_param;
894
/* link to select_lex where this table was used */
895
st_select_lex *select_lex;
896
Field_translator *field_translation; /* array of VIEW fields */
897
/* pointer to element after last one in translation table above */
898
Field_translator *field_translation_end;
900
List (based on next_local) of underlying tables of this view. I.e. it
901
does not include the tables of subqueries used in the view. Is set only
904
TABLE_LIST *merge_underlying_list;
907
- in case of the view it is the list of all (not only underlying
908
tables but also used in subquery ones) tables of the view.
910
List<TABLE_LIST> *view_tables;
911
/* most upper view this table belongs to */
912
TABLE_LIST *belong_to_view;
913
/* Ptr to parent MERGE table list item. See top comment in ha_myisammrg.cc */
914
TABLE_LIST *parent_l;
916
List of all base tables local to a subquery including all view
917
tables. Unlike 'next_local', this in this list views are *not*
918
leaves. Created in setup_tables() -> make_leaves_list().
920
TABLE_LIST *next_leaf;
921
/* data need by some engines in query cache*/
922
uint64_t engine_data;
923
/* call back function for asking handler about caching in query cache */
924
qc_engine_callback callback_func;
925
thr_lock_type lock_type;
926
uint outer_join; /* Which join type */
927
uint shared; /* Used in multi-upd */
929
size_t table_name_length;
930
bool straight; /* optimize with prev table */
931
bool updating; /* for replicate-do/ignore table */
932
bool force_index; /* prefer index over table scan */
933
bool ignore_leaves; /* preload only non-leaf nodes */
934
table_map dep_tables; /* tables the table depends on */
935
table_map on_expr_dep_tables; /* tables on expression depends on */
936
struct st_nested_join *nested_join; /* if the element is a nested join */
937
TABLE_LIST *embedding; /* nested join containing the table */
938
List<TABLE_LIST> *join_list;/* join list the table belongs to */
939
bool cacheable_table; /* stop PS caching */
940
/* FRMTYPE_ERROR if any type is acceptable */
941
enum frm_type_enum required_type;
942
handlerton *db_type; /* table_type for handler */
943
char timestamp_buffer[20]; /* buffer for timestamp (19+1) */
945
This TABLE_LIST object corresponds to the table to be created
946
so it is possible that it does not exist (used in CREATE TABLE
947
... SELECT implementation).
950
/* For transactional locking. */
951
int lock_timeout; /* NOWAIT or WAIT [X] */
952
bool lock_transactional; /* If transactional lock requested. */
953
bool internal_tmp_table;
954
/** TRUE if an alias for this table was specified in the SQL. */
956
/** TRUE if the table is referred to in the statement using a fully
957
qualified name (<db_name>.<table_name>).
961
uint i_s_requested_object;
962
bool has_db_lookup_value;
963
bool has_table_lookup_value;
964
uint table_open_method;
965
enum enum_schema_table_state schema_table_state;
966
void set_underlying_merge();
967
bool setup_underlying(THD *thd);
968
void cleanup_items();
970
If you change placeholder(), please check the condition in
971
check_transactional_lock() too.
975
return derived || schema_table || (create && !table->db_stat) || !table;
977
void print(THD *thd, String *str, enum_query_type query_type);
978
bool set_insert_values(MEM_ROOT *mem_root);
979
TABLE_LIST *find_underlying_table(TABLE *table);
980
TABLE_LIST *first_leaf_for_name_resolution();
981
TABLE_LIST *last_leaf_for_name_resolution();
982
bool is_leaf_for_name_resolution();
983
inline TABLE_LIST *top_table()
984
{ return belong_to_view ? belong_to_view : this; }
987
Cleanup for re-execution in a prepared statement or a stored
990
void reinit_before_use(THD *thd);
991
Item_subselect *containing_subselect();
994
Compiles the tagged hints list and fills up st_table::keys_in_use_for_query,
995
st_table::keys_in_use_for_group_by, st_table::keys_in_use_for_order_by,
996
st_table::force_index and st_table::covering_keys.
998
bool process_index_hints(TABLE *table);
1001
bool prep_where(THD *thd, Item **conds, bool no_where_clause);
1003
Cleanup for re-execution in a prepared statement or a stored
1011
Iterator over the fields of a generic table reference.
1014
class Field_iterator: public Sql_alloc
1017
Field_iterator() {} /* Remove gcc warning */
1018
virtual ~Field_iterator() {}
1019
virtual void set(TABLE_LIST *)= 0;
1020
virtual void next()= 0;
1021
virtual bool end_of_fields()= 0; /* Return 1 at end of list */
1022
virtual const char *name()= 0;
1023
virtual Item *create_item(THD *)= 0;
1024
virtual Field *field()= 0;
1029
Iterator over the fields of a base table, view with temporary
1033
class Field_iterator_table: public Field_iterator
1037
Field_iterator_table() :ptr(0) {}
1038
void set(TABLE_LIST *table) { ptr= table->table->field; }
1039
void set_table(TABLE *table) { ptr= table->field; }
1040
void next() { ptr++; }
1041
bool end_of_fields() { return *ptr == 0; }
1043
Item *create_item(THD *thd);
1044
Field *field() { return *ptr; }
1048
/* Iterator over the fields of a merge view. */
1050
class Field_iterator_view: public Field_iterator
1052
Field_translator *ptr, *array_end;
1055
Field_iterator_view() :ptr(0), array_end(0) {}
1056
void set(TABLE_LIST *table);
1057
void next() { ptr++; }
1058
bool end_of_fields() { return ptr == array_end; }
1060
Item *create_item(THD *thd);
1061
Item **item_ptr() {return &ptr->item; }
1062
Field *field() { return 0; }
1063
inline Item *item() { return ptr->item; }
1064
Field_translator *field_translator() { return ptr; }
1069
Field_iterator interface to the list of materialized fields of a
1073
class Field_iterator_natural_join: public Field_iterator
1075
List_iterator_fast<Natural_join_column> column_ref_it;
1076
Natural_join_column *cur_column_ref;
1078
Field_iterator_natural_join() :cur_column_ref(NULL) {}
1079
~Field_iterator_natural_join() {}
1080
void set(TABLE_LIST *table);
1082
bool end_of_fields() { return !cur_column_ref; }
1083
const char *name() { return cur_column_ref->name(); }
1084
Item *create_item(THD *thd) { return cur_column_ref->create_item(thd); }
1085
Field *field() { return cur_column_ref->field(); }
1086
Natural_join_column *column_ref() { return cur_column_ref; }
1091
Generic iterator over the fields of an arbitrary table reference.
1094
This class unifies the various ways of iterating over the columns
1095
of a table reference depending on the type of SQL entity it
1096
represents. If such an entity represents a nested table reference,
1097
this iterator encapsulates the iteration over the columns of the
1098
members of the table reference.
1101
The implementation assumes that all underlying NATURAL/USING table
1102
references already contain their result columns and are linked into
1103
the list TABLE_LIST::next_name_resolution_table.
1106
class Field_iterator_table_ref: public Field_iterator
1108
TABLE_LIST *table_ref, *first_leaf, *last_leaf;
1109
Field_iterator_table table_field_it;
1110
Field_iterator_view view_field_it;
1111
Field_iterator_natural_join natural_join_it;
1112
Field_iterator *field_it;
1113
void set_field_iterator();
1115
Field_iterator_table_ref() :field_it(NULL) {}
1116
void set(TABLE_LIST *table);
1118
bool end_of_fields()
1119
{ return (table_ref == last_leaf && field_it->end_of_fields()); }
1120
const char *name() { return field_it->name(); }
1121
const char *table_name();
1122
const char *db_name();
1123
Item *create_item(THD *thd) { return field_it->create_item(thd); }
1124
Field *field() { return field_it->field(); }
1125
Natural_join_column *get_or_create_column_ref(TABLE_LIST *parent_table_ref);
1126
Natural_join_column *get_natural_column_ref();
1130
typedef struct st_nested_join
1132
List<TABLE_LIST> join_list; /* list of elements in the nested join */
1133
table_map used_tables; /* bitmap of tables in the nested join */
1134
table_map not_null_tables; /* tables that rejects nulls */
1135
struct st_join_table *first_nested;/* the first nested table in the plan */
1137
Used to count tables in the nested join in 2 isolated places:
1138
1. In make_outerjoin_info().
1139
2. check_interleaving_with_nj/restore_prev_nj_state (these are called
1140
by the join optimizer.
1141
Before each use the counters are zeroed by reset_nj_counters.
1144
nested_join_map nj_map; /* Bit used to identify this nested join*/
1146
(Valid only for semi-join nests) Bitmap of tables outside the semi-join
1147
that are used within the semi-join's ON condition.
1149
table_map sj_depends_on;
1150
/* Outer non-trivially correlated tables */
1151
table_map sj_corr_tables;
1152
List<Item> sj_outer_expr_list;
1156
typedef struct st_changed_table_list
1158
struct st_changed_table_list *next;
1161
} CHANGED_TABLE_LIST;
1164
typedef struct st_open_table_list{
1165
struct st_open_table_list *next;
1167
uint32 in_use,locked;
1170
typedef struct st_table_field_w_type
1175
} TABLE_FIELD_W_TYPE;
1179
table_check_intact(TABLE *table, const uint table_f_count,
1180
const TABLE_FIELD_W_TYPE *table_def);
1182
static inline my_bitmap_map *tmp_use_all_columns(TABLE *table,
1185
my_bitmap_map *old= bitmap->bitmap;
1186
bitmap->bitmap= table->s->all_set.bitmap;
1191
static inline void tmp_restore_column_map(MY_BITMAP *bitmap,
1194
bitmap->bitmap= old;
1197
/* The following is only needed for debugging */
1199
static inline my_bitmap_map *dbug_tmp_use_all_columns(TABLE *table,
1203
return tmp_use_all_columns(table, bitmap);
1209
static inline void dbug_tmp_restore_column_map(MY_BITMAP *bitmap,
1213
tmp_restore_column_map(bitmap, old);
1217
size_t max_row_length(TABLE *table, const uchar *data);
added
removed
sql/table.h
