← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/dict0mem.h

Renamed namespace slot to namespace service.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/dict0mem.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (C) 1996, 2010, Innobase Oy. All Rights Reserved.
4
 
 
5
 
This program is free software; you can redistribute it and/or modify it under
6
 
the terms of the GNU General Public License as published by the Free Software
7
 
Foundation; version 2 of the License.
8
 
 
9
 
This program is distributed in the hope that it will be useful, but WITHOUT
10
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
 
 
13
 
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15
 
St, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/**************************************************//**
20
 
@file include/dict0mem.h
21
 
Data dictionary memory object creation
22
 
 
23
 
Created 1/8/1996 Heikki Tuuri
24
 
*******************************************************/
25
 
 
26
 
#ifndef dict0mem_h
27
 
#define dict0mem_h
28
 
 
29
 
#include "univ.i"
30
 
#include "dict0types.h"
31
 
#include "data0type.h"
32
 
#include "mem0mem.h"
33
 
#include "rem0types.h"
34
 
#include "btr0types.h"
35
 
#ifndef UNIV_HOTBACKUP
36
 
# include "lock0types.h"
37
 
# include "que0types.h"
38
 
# include "sync0rw.h"
39
 
#endif /* !UNIV_HOTBACKUP */
40
 
#include "ut0mem.h"
41
 
#include "ut0lst.h"
42
 
#include "ut0rnd.h"
43
 
#include "ut0byte.h"
44
 
#include "hash0hash.h"
45
 
#include "trx0types.h"
46
 
 
47
 
/** Type flags of an index: OR'ing of the flags is allowed to define a
48
 
combination of types */
49
 
/* @{ */
50
 
#define DICT_CLUSTERED  1       /*!< clustered index */
51
 
#define DICT_UNIQUE     2       /*!< unique index */
52
 
#define DICT_UNIVERSAL  4       /*!< index which can contain records from any
53
 
                                other index */
54
 
#define DICT_IBUF       8       /*!< insert buffer tree */
55
 
/* @} */
56
 
 
57
 
/** Types for a table object */
58
 
#define DICT_TABLE_ORDINARY             1 /*!< ordinary table */
59
 
#if 0 /* not implemented */
60
 
#define DICT_TABLE_CLUSTER_MEMBER       2
61
 
#define DICT_TABLE_CLUSTER              3 /* this means that the table is
62
 
                                          really a cluster definition */
63
 
#endif
64
 
 
65
 
/** Table flags.  All unused bits must be 0. */
66
 
/* @{ */
67
 
#define DICT_TF_COMPACT                 1       /* Compact page format.
68
 
                                                This must be set for
69
 
                                                new file formats
70
 
                                                (later than
71
 
                                                DICT_TF_FORMAT_51). */
72
 
 
73
 
/** Compressed page size (0=uncompressed, up to 15 compressed sizes) */
74
 
/* @{ */
75
 
#define DICT_TF_ZSSIZE_SHIFT            1
76
 
#define DICT_TF_ZSSIZE_MASK             (15 << DICT_TF_ZSSIZE_SHIFT)
77
 
#define DICT_TF_ZSSIZE_MAX (UNIV_PAGE_SIZE_SHIFT - PAGE_ZIP_MIN_SIZE_SHIFT + 1)
78
 
/* @} */
79
 
 
80
 
/** File format */
81
 
/* @{ */
82
 
#define DICT_TF_FORMAT_SHIFT            5       /* file format */
83
 
#define DICT_TF_FORMAT_MASK             \
84
 
((~(~0 << (DICT_TF_BITS - DICT_TF_FORMAT_SHIFT))) << DICT_TF_FORMAT_SHIFT)
85
 
#define DICT_TF_FORMAT_51               0       /*!< InnoDB/MySQL up to 5.1 */
86
 
#define DICT_TF_FORMAT_ZIP              1       /*!< InnoDB plugin for 5.1:
87
 
                                                compressed tables,
88
 
                                                new BLOB treatment */
89
 
/** Maximum supported file format */
90
 
#define DICT_TF_FORMAT_MAX              DICT_TF_FORMAT_ZIP
91
 
 
92
 
/** Minimum supported file format */
93
 
#define DICT_TF_FORMAT_MIN              DICT_TF_FORMAT_51
94
 
 
95
 
/* @} */
96
 
#define DICT_TF_BITS                    6       /*!< number of flag bits */
97
 
#if (1 << (DICT_TF_BITS - DICT_TF_FORMAT_SHIFT)) <= DICT_TF_FORMAT_MAX
98
 
# error "DICT_TF_BITS is insufficient for DICT_TF_FORMAT_MAX"
99
 
#endif
100
 
/* @} */
101
 
 
102
 
/** @brief Additional table flags.
103
 
 
104
 
These flags will be stored in SYS_TABLES.MIX_LEN.  All unused flags
105
 
will be written as 0.  The column may contain garbage for tables
106
 
created with old versions of InnoDB that only implemented
107
 
ROW_FORMAT=REDUNDANT. */
108
 
/* @{ */
109
 
#define DICT_TF2_SHIFT                  DICT_TF_BITS
110
 
                                                /*!< Shift value for
111
 
                                                table->flags. */
112
 
#define DICT_TF2_TEMPORARY              1       /*!< TRUE for tables from
113
 
                                                CREATE TEMPORARY TABLE. */
114
 
#define DICT_TF2_BITS                   (DICT_TF2_SHIFT + 1)
115
 
                                                /*!< Total number of bits
116
 
                                                in table->flags. */
117
 
/* @} */
118
 
 
119
 
/** Tables could be chained together with Foreign key constraint. When
120
 
first load the parent table, we would load all of its descedents.
121
 
This could result in rescursive calls and out of stack error eventually.
122
 
DICT_FK_MAX_RECURSIVE_LOAD defines the maximum number of recursive loads,
123
 
when exceeded, the child table will not be loaded. It will be loaded when
124
 
the foreign constraint check needs to be run. */
125
 
#define DICT_FK_MAX_RECURSIVE_LOAD      255
126
 
 
127
 
/** Similarly, when tables are chained together with foreign key constraints
128
 
with on cascading delete/update clause, delete from parent table could
129
 
result in recursive cascading calls. This defines the maximum number of
130
 
such cascading deletes/updates allowed. When exceeded, the delete from
131
 
parent table will fail, and user has to drop excessive foreign constraint
132
 
before proceeds. */
133
 
#define FK_MAX_CASCADE_DEL              255
134
 
 
135
 
/**********************************************************************//**
136
 
Creates a table memory object.
137
 
@return own: table object */
138
 
UNIV_INTERN
139
 
dict_table_t*
140
 
dict_mem_table_create(
141
 
/*==================*/
142
 
        const char*     name,           /*!< in: table name */
143
 
        ulint           space,          /*!< in: space where the clustered index
144
 
                                        of the table is placed; this parameter
145
 
                                        is ignored if the table is made
146
 
                                        a member of a cluster */
147
 
        ulint           n_cols,         /*!< in: number of columns */
148
 
        ulint           flags);         /*!< in: table flags */
149
 
/****************************************************************//**
150
 
Free a table memory object. */
151
 
UNIV_INTERN
152
 
void
153
 
dict_mem_table_free(
154
 
/*================*/
155
 
        dict_table_t*   table);         /*!< in: table */
156
 
/**********************************************************************//**
157
 
Adds a column definition to a table. */
158
 
UNIV_INTERN
159
 
void
160
 
dict_mem_table_add_col(
161
 
/*===================*/
162
 
        dict_table_t*   table,  /*!< in: table */
163
 
        mem_heap_t*     heap,   /*!< in: temporary memory heap, or NULL */
164
 
        const char*     name,   /*!< in: column name, or NULL */
165
 
        ulint           mtype,  /*!< in: main datatype */
166
 
        ulint           prtype, /*!< in: precise type */
167
 
        ulint           len);   /*!< in: precision */
168
 
/**********************************************************************//**
169
 
This function populates a dict_col_t memory structure with
170
 
supplied information. */
171
 
UNIV_INTERN
172
 
void
173
 
dict_mem_fill_column_struct(
174
 
/*========================*/
175
 
        dict_col_t*     column,         /*!< out: column struct to be
176
 
                                        filled */
177
 
        ulint           col_pos,        /*!< in: column position */
178
 
        ulint           mtype,          /*!< in: main data type */
179
 
        ulint           prtype,         /*!< in: precise type */
180
 
        ulint           col_len);       /*!< in: column length */
181
 
/**********************************************************************//**
182
 
This function poplulates a dict_index_t index memory structure with
183
 
supplied information. */
184
 
UNIV_INLINE
185
 
void
186
 
dict_mem_fill_index_struct(
187
 
/*=======================*/
188
 
        dict_index_t*   index,          /*!< out: index to be filled */
189
 
        mem_heap_t*     heap,           /*!< in: memory heap */
190
 
        const char*     table_name,     /*!< in: table name */
191
 
        const char*     index_name,     /*!< in: index name */
192
 
        ulint           space,          /*!< in: space where the index tree is
193
 
                                        placed, ignored if the index is of
194
 
                                        the clustered type */
195
 
        ulint           type,           /*!< in: DICT_UNIQUE,
196
 
                                        DICT_CLUSTERED, ... ORed */
197
 
        ulint           n_fields);      /*!< in: number of fields */
198
 
/**********************************************************************//**
199
 
Creates an index memory object.
200
 
@return own: index object */
201
 
UNIV_INTERN
202
 
dict_index_t*
203
 
dict_mem_index_create(
204
 
/*==================*/
205
 
        const char*     table_name,     /*!< in: table name */
206
 
        const char*     index_name,     /*!< in: index name */
207
 
        ulint           space,          /*!< in: space where the index tree is
208
 
                                        placed, ignored if the index is of
209
 
                                        the clustered type */
210
 
        ulint           type,           /*!< in: DICT_UNIQUE,
211
 
                                        DICT_CLUSTERED, ... ORed */
212
 
        ulint           n_fields);      /*!< in: number of fields */
213
 
/**********************************************************************//**
214
 
Adds a field definition to an index. NOTE: does not take a copy
215
 
of the column name if the field is a column. The memory occupied
216
 
by the column name may be released only after publishing the index. */
217
 
UNIV_INTERN
218
 
void
219
 
dict_mem_index_add_field(
220
 
/*=====================*/
221
 
        dict_index_t*   index,          /*!< in: index */
222
 
        const char*     name,           /*!< in: column name */
223
 
        ulint           prefix_len);    /*!< in: 0 or the column prefix length
224
 
                                        in a MySQL index like
225
 
                                        INDEX (textcol(25)) */
226
 
/**********************************************************************//**
227
 
Frees an index memory object. */
228
 
UNIV_INTERN
229
 
void
230
 
dict_mem_index_free(
231
 
/*================*/
232
 
        dict_index_t*   index); /*!< in: index */
233
 
/**********************************************************************//**
234
 
Creates and initializes a foreign constraint memory object.
235
 
@return own: foreign constraint struct */
236
 
UNIV_INTERN
237
 
dict_foreign_t*
238
 
dict_mem_foreign_create(void);
239
 
/*=========================*/
240
 
 
241
 
/** Data structure for a column in a table */
242
 
struct dict_col_struct{
243
 
        /*----------------------*/
244
 
        /** The following are copied from dtype_t,
245
 
        so that all bit-fields can be packed tightly. */
246
 
        /* @{ */
247
 
        unsigned        mtype:8;        /*!< main data type */
248
 
        unsigned        prtype:24;      /*!< precise type; MySQL data
249
 
                                        type, charset code, flags to
250
 
                                        indicate nullability,
251
 
                                        signedness, whether this is a
252
 
                                        binary string, whether this is
253
 
                                        a true VARCHAR where MySQL
254
 
                                        uses 2 bytes to store the length */
255
 
 
256
 
        /* the remaining fields do not affect alphabetical ordering: */
257
 
 
258
 
        unsigned        len:16;         /*!< length; for MySQL data this
259
 
                                        is field->pack_length(),
260
 
                                        except that for a >= 5.0.3
261
 
                                        type true VARCHAR this is the
262
 
                                        maximum byte length of the
263
 
                                        string data (in addition to
264
 
                                        the string, MySQL uses 1 or 2
265
 
                                        bytes to store the string length) */
266
 
 
267
 
        unsigned        mbminmaxlen:5;  /*!< minimum and maximum length of a
268
 
                                        character, in bytes;
269
 
                                        DATA_MBMINMAXLEN(mbminlen,mbmaxlen);
270
 
                                        mbminlen=DATA_MBMINLEN(mbminmaxlen);
271
 
                                        mbmaxlen=DATA_MBMINLEN(mbminmaxlen) */
272
 
        /*----------------------*/
273
 
        /* End of definitions copied from dtype_t */
274
 
        /* @} */
275
 
 
276
 
        unsigned        ind:10;         /*!< table column position
277
 
                                        (starting from 0) */
278
 
        unsigned        ord_part:1;     /*!< nonzero if this column
279
 
                                        appears in the ordering fields
280
 
                                        of an index */
281
 
};
282
 
 
283
 
/** @brief DICT_MAX_INDEX_COL_LEN is measured in bytes and is the maximum
284
 
indexed column length (or indexed prefix length).
285
 
 
286
 
It is set to 3*256, so that one can create a column prefix index on
287
 
256 characters of a TEXT or VARCHAR column also in the UTF-8
288
 
charset. In that charset, a character may take at most 3 bytes.  This
289
 
constant MUST NOT BE CHANGED, or the compatibility of InnoDB data
290
 
files would be at risk! */
291
 
#define DICT_MAX_INDEX_COL_LEN          REC_MAX_INDEX_COL_LEN
292
 
 
293
 
/** Data structure for a field in an index */
294
 
struct dict_field_struct{
295
 
        dict_col_t*     col;            /*!< pointer to the table column */
296
 
        const char*     name;           /*!< name of the column */
297
 
        unsigned        prefix_len:10;  /*!< 0 or the length of the column
298
 
                                        prefix in bytes in a MySQL index of
299
 
                                        type, e.g., INDEX (textcol(25));
300
 
                                        must be smaller than
301
 
                                        DICT_MAX_INDEX_COL_LEN; NOTE that
302
 
                                        in the UTF-8 charset, MySQL sets this
303
 
                                        to 3 * the prefix len in UTF-8 chars */
304
 
        unsigned        fixed_len:10;   /*!< 0 or the fixed length of the
305
 
                                        column if smaller than
306
 
                                        DICT_MAX_INDEX_COL_LEN */
307
 
};
308
 
 
309
 
/** Data structure for an index.  Most fields will be
310
 
initialized to 0, NULL or FALSE in dict_mem_index_create(). */
311
 
struct dict_index_struct{
312
 
        index_id_t      id;     /*!< id of the index */
313
 
        mem_heap_t*     heap;   /*!< memory heap */
314
 
        const char*     name;   /*!< index name */
315
 
        const char*     table_name;/*!< table name */
316
 
        dict_table_t*   table;  /*!< back pointer to table */
317
 
#ifndef UNIV_HOTBACKUP
318
 
        unsigned        space:32;
319
 
                                /*!< space where the index tree is placed */
320
 
        unsigned        page:32;/*!< index tree root page number */
321
 
#endif /* !UNIV_HOTBACKUP */
322
 
        unsigned        type:4; /*!< index type (DICT_CLUSTERED, DICT_UNIQUE,
323
 
                                DICT_UNIVERSAL, DICT_IBUF) */
324
 
        unsigned        trx_id_offset:10;/*!< position of the trx id column
325
 
                                in a clustered index record, if the fields
326
 
                                before it are known to be of a fixed size,
327
 
                                0 otherwise */
328
 
        unsigned        n_user_defined_cols:10;
329
 
                                /*!< number of columns the user defined to
330
 
                                be in the index: in the internal
331
 
                                representation we add more columns */
332
 
        unsigned        n_uniq:10;/*!< number of fields from the beginning
333
 
                                which are enough to determine an index
334
 
                                entry uniquely */
335
 
        unsigned        n_def:10;/*!< number of fields defined so far */
336
 
        unsigned        n_fields:10;/*!< number of fields in the index */
337
 
        unsigned        n_nullable:10;/*!< number of nullable fields */
338
 
        unsigned        cached:1;/*!< TRUE if the index object is in the
339
 
                                dictionary cache */
340
 
        unsigned        to_be_dropped:1;
341
 
                                /*!< TRUE if this index is marked to be
342
 
                                dropped in ha_innobase::prepare_drop_index(),
343
 
                                otherwise FALSE */
344
 
        dict_field_t*   fields; /*!< array of field descriptions */
345
 
#ifndef UNIV_HOTBACKUP
346
 
        UT_LIST_NODE_T(dict_index_t)
347
 
                        indexes;/*!< list of indexes of the table */
348
 
        btr_search_t*   search_info; /*!< info used in optimistic searches */
349
 
        /*----------------------*/
350
 
        /** Statistics for query optimization */
351
 
        /* @{ */
352
 
        ib_int64_t*     stat_n_diff_key_vals;
353
 
                                /*!< approximate number of different
354
 
                                key values for this index, for each
355
 
                                n-column prefix where n <=
356
 
                                dict_get_n_unique(index); we
357
 
                                periodically calculate new
358
 
                                estimates */
359
 
        ulint           stat_index_size;
360
 
                                /*!< approximate index size in
361
 
                                database pages */
362
 
        ulint           stat_n_leaf_pages;
363
 
                                /*!< approximate number of leaf pages in the
364
 
                                index tree */
365
 
        /* @} */
366
 
        rw_lock_t       lock;   /*!< read-write lock protecting the
367
 
                                upper levels of the index tree */
368
 
        trx_id_t        trx_id; /*!< id of the transaction that created this
369
 
                                index, or 0 if the index existed
370
 
                                when InnoDB was started up */
371
 
#endif /* !UNIV_HOTBACKUP */
372
 
#ifdef UNIV_DEBUG
373
 
        ulint           magic_n;/*!< magic number */
374
 
/** Value of dict_index_struct::magic_n */
375
 
# define DICT_INDEX_MAGIC_N     76789786
376
 
#endif
377
 
};
378
 
 
379
 
/** Data structure for a foreign key constraint; an example:
380
 
FOREIGN KEY (A, B) REFERENCES TABLE2 (C, D).  Most fields will be
381
 
initialized to 0, NULL or FALSE in dict_mem_foreign_create(). */
382
 
struct dict_foreign_struct{
383
 
        mem_heap_t*     heap;           /*!< this object is allocated from
384
 
                                        this memory heap */
385
 
        char*           id;             /*!< id of the constraint as a
386
 
                                        null-terminated string */
387
 
        unsigned        n_fields:10;    /*!< number of indexes' first fields
388
 
                                        for which the the foreign key
389
 
                                        constraint is defined: we allow the
390
 
                                        indexes to contain more fields than
391
 
                                        mentioned in the constraint, as long
392
 
                                        as the first fields are as mentioned */
393
 
        unsigned        type:6;         /*!< 0 or DICT_FOREIGN_ON_DELETE_CASCADE
394
 
                                        or DICT_FOREIGN_ON_DELETE_SET_NULL */
395
 
        char*           foreign_table_name;/*!< foreign table name */
396
 
        dict_table_t*   foreign_table;  /*!< table where the foreign key is */
397
 
        const char**    foreign_col_names;/*!< names of the columns in the
398
 
                                        foreign key */
399
 
        char*           referenced_table_name;/*!< referenced table name */
400
 
        dict_table_t*   referenced_table;/*!< table where the referenced key
401
 
                                        is */
402
 
        const char**    referenced_col_names;/*!< names of the referenced
403
 
                                        columns in the referenced table */
404
 
        dict_index_t*   foreign_index;  /*!< foreign index; we require that
405
 
                                        both tables contain explicitly defined
406
 
                                        indexes for the constraint: InnoDB
407
 
                                        does not generate new indexes
408
 
                                        implicitly */
409
 
        dict_index_t*   referenced_index;/*!< referenced index */
410
 
        UT_LIST_NODE_T(dict_foreign_t)
411
 
                        foreign_list;   /*!< list node for foreign keys of the
412
 
                                        table */
413
 
        UT_LIST_NODE_T(dict_foreign_t)
414
 
                        referenced_list;/*!< list node for referenced
415
 
                                        keys of the table */
416
 
};
417
 
 
418
 
/** The flags for ON_UPDATE and ON_DELETE can be ORed; the default is that
419
 
a foreign key constraint is enforced, therefore RESTRICT just means no flag */
420
 
/* @{ */
421
 
#define DICT_FOREIGN_ON_DELETE_CASCADE  1       /*!< ON DELETE CASCADE */
422
 
#define DICT_FOREIGN_ON_DELETE_SET_NULL 2       /*!< ON UPDATE SET NULL */
423
 
#define DICT_FOREIGN_ON_UPDATE_CASCADE  4       /*!< ON DELETE CASCADE */
424
 
#define DICT_FOREIGN_ON_UPDATE_SET_NULL 8       /*!< ON UPDATE SET NULL */
425
 
#define DICT_FOREIGN_ON_DELETE_NO_ACTION 16     /*!< ON DELETE NO ACTION */
426
 
#define DICT_FOREIGN_ON_UPDATE_NO_ACTION 32     /*!< ON UPDATE NO ACTION */
427
 
/* @} */
428
 
 
429
 
 
430
 
/** Data structure for a database table.  Most fields will be
431
 
initialized to 0, NULL or FALSE in dict_mem_table_create(). */
432
 
struct dict_table_struct{
433
 
        table_id_t      id;     /*!< id of the table */
434
 
        mem_heap_t*     heap;   /*!< memory heap */
435
 
        char*           name;   /*!< table name */
436
 
        const char*     dir_path_of_temp_table;/*!< NULL or the directory path
437
 
                                where a TEMPORARY table that was explicitly
438
 
                                created by a user should be placed if
439
 
                                innodb_file_per_table is defined in my.cnf;
440
 
                                in Unix this is usually /tmp/..., in Windows
441
 
                                temp\... */
442
 
        unsigned        space:32;
443
 
                                /*!< space where the clustered index of the
444
 
                                table is placed */
445
 
        unsigned        flags:DICT_TF2_BITS;/*!< DICT_TF_COMPACT, ... */
446
 
        unsigned        ibd_file_missing:1;
447
 
                                /*!< TRUE if this is in a single-table
448
 
                                tablespace and the .ibd file is missing; then
449
 
                                we must return in ha_innodb.cc an error if the
450
 
                                user tries to query such an orphaned table */
451
 
        unsigned        tablespace_discarded:1;
452
 
                                /*!< this flag is set TRUE when the user
453
 
                                calls DISCARD TABLESPACE on this
454
 
                                table, and reset to FALSE in IMPORT
455
 
                                TABLESPACE */
456
 
        unsigned        cached:1;/*!< TRUE if the table object has been added
457
 
                                to the dictionary cache */
458
 
        unsigned        n_def:10;/*!< number of columns defined so far */
459
 
        unsigned        n_cols:10;/*!< number of columns */
460
 
        dict_col_t*     cols;   /*!< array of column descriptions */
461
 
        const char*     col_names;
462
 
                                /*!< Column names packed in a character string
463
 
                                "name1\0name2\0...nameN\0".  Until
464
 
                                the string contains n_cols, it will be
465
 
                                allocated from a temporary heap.  The final
466
 
                                string will be allocated from table->heap. */
467
 
#ifndef UNIV_HOTBACKUP
468
 
        hash_node_t     name_hash; /*!< hash chain node */
469
 
        hash_node_t     id_hash; /*!< hash chain node */
470
 
        UT_LIST_BASE_NODE_T(dict_index_t)
471
 
                        indexes; /*!< list of indexes of the table */
472
 
        UT_LIST_BASE_NODE_T(dict_foreign_t)
473
 
                        foreign_list;/*!< list of foreign key constraints
474
 
                                in the table; these refer to columns
475
 
                                in other tables */
476
 
        UT_LIST_BASE_NODE_T(dict_foreign_t)
477
 
                        referenced_list;/*!< list of foreign key constraints
478
 
                                which refer to this table */
479
 
        UT_LIST_NODE_T(dict_table_t)
480
 
                        table_LRU; /*!< node of the LRU list of tables */
481
 
        ulint           n_mysql_handles_opened;
482
 
                                /*!< count of how many handles MySQL has opened
483
 
                                to this table; dropping of the table is
484
 
                                NOT allowed until this count gets to zero;
485
 
                                MySQL does NOT itself check the number of
486
 
                                open handles at drop */
487
 
        unsigned        fk_max_recusive_level:8;
488
 
                                /*!< maximum recursive level we support when
489
 
                                loading tables chained together with FK
490
 
                                constraints. If exceeds this level, we will
491
 
                                stop loading child table into memory along with
492
 
                                its parent table */
493
 
        ulint           n_foreign_key_checks_running;
494
 
                                /*!< count of how many foreign key check
495
 
                                operations are currently being performed
496
 
                                on the table: we cannot drop the table while
497
 
                                there are foreign key checks running on
498
 
                                it! */
499
 
        trx_id_t        query_cache_inv_trx_id;
500
 
                                /*!< transactions whose trx id is
501
 
                                smaller than this number are not
502
 
                                allowed to store to the MySQL query
503
 
                                cache or retrieve from it; when a trx
504
 
                                with undo logs commits, it sets this
505
 
                                to the value of the trx id counter for
506
 
                                the tables it had an IX lock on */
507
 
        UT_LIST_BASE_NODE_T(lock_t)
508
 
                        locks; /*!< list of locks on the table */
509
 
#ifdef UNIV_DEBUG
510
 
        /*----------------------*/
511
 
        ibool           does_not_fit_in_memory;
512
 
                                /*!< this field is used to specify in
513
 
                                simulations tables which are so big
514
 
                                that disk should be accessed: disk
515
 
                                access is simulated by putting the
516
 
                                thread to sleep for a while; NOTE that
517
 
                                this flag is not stored to the data
518
 
                                dictionary on disk, and the database
519
 
                                will forget about value TRUE if it has
520
 
                                to reload the table definition from
521
 
                                disk */
522
 
#endif /* UNIV_DEBUG */
523
 
        /*----------------------*/
524
 
        unsigned        big_rows:1;
525
 
                                /*!< flag: TRUE if the maximum length of
526
 
                                a single row exceeds BIG_ROW_SIZE;
527
 
                                initialized in dict_table_add_to_cache() */
528
 
                                /** Statistics for query optimization */
529
 
                                /* @{ */
530
 
        unsigned        stat_initialized:1; /*!< TRUE if statistics have
531
 
                                been calculated the first time
532
 
                                after database startup or table creation */
533
 
        ib_int64_t      stat_n_rows;
534
 
                                /*!< approximate number of rows in the table;
535
 
                                we periodically calculate new estimates */
536
 
        ulint           stat_clustered_index_size;
537
 
                                /*!< approximate clustered index size in
538
 
                                database pages */
539
 
        ulint           stat_sum_of_other_index_sizes;
540
 
                                /*!< other indexes in database pages */
541
 
        ulint           stat_modified_counter;
542
 
                                /*!< when a row is inserted, updated,
543
 
                                or deleted,
544
 
                                we add 1 to this number; we calculate new
545
 
                                estimates for the stat_... values for the
546
 
                                table and the indexes at an interval of 2 GB
547
 
                                or when about 1 / 16 of table has been
548
 
                                modified; also when the estimate operation is
549
 
                                called for MySQL SHOW TABLE STATUS; the
550
 
                                counter is reset to zero at statistics
551
 
                                calculation; this counter is not protected by
552
 
                                any latch, because this is only used for
553
 
                                heuristics */
554
 
                                /* @} */
555
 
        /*----------------------*/
556
 
                                /**!< The following fields are used by the
557
 
                                AUTOINC code.  The actual collection of
558
 
                                tables locked during AUTOINC read/write is
559
 
                                kept in trx_t. In order to quickly determine
560
 
                                whether a transaction has locked the AUTOINC
561
 
                                lock we keep a pointer to the transaction
562
 
                                here in the autoinc_trx variable. This is to
563
 
                                avoid acquiring the kernel mutex and scanning
564
 
                                the vector in trx_t.
565
 
 
566
 
                                When an AUTOINC lock has to wait, the
567
 
                                corresponding lock instance is created on
568
 
                                the trx lock heap rather than use the
569
 
                                pre-allocated instance in autoinc_lock below.*/
570
 
                                /* @{ */
571
 
        lock_t*         autoinc_lock;
572
 
                                /*!< a buffer for an AUTOINC lock
573
 
                                for this table: we allocate the memory here
574
 
                                so that individual transactions can get it
575
 
                                and release it without a need to allocate
576
 
                                space from the lock heap of the trx:
577
 
                                otherwise the lock heap would grow rapidly
578
 
                                if we do a large insert from a select */
579
 
        mutex_t         autoinc_mutex;
580
 
                                /*!< mutex protecting the autoincrement
581
 
                                counter */
582
 
        ib_uint64_t     autoinc;/*!< autoinc counter value to give to the
583
 
                                next inserted row */
584
 
        ulong           n_waiting_or_granted_auto_inc_locks;
585
 
                                /*!< This counter is used to track the number
586
 
                                of granted and pending autoinc locks on this
587
 
                                table. This value is set after acquiring the
588
 
                                kernel mutex but we peek the contents to
589
 
                                determine whether other transactions have
590
 
                                acquired the AUTOINC lock or not. Of course
591
 
                                only one transaction can be granted the
592
 
                                lock but there can be multiple waiters. */
593
 
        const trx_t*            autoinc_trx;
594
 
                                /*!< The transaction that currently holds the
595
 
                                the AUTOINC lock on this table. */
596
 
                                /* @} */
597
 
        /*----------------------*/
598
 
#endif /* !UNIV_HOTBACKUP */
599
 
 
600
 
#ifdef UNIV_DEBUG
601
 
        ulint           magic_n;/*!< magic number */
602
 
/** Value of dict_table_struct::magic_n */
603
 
# define DICT_TABLE_MAGIC_N     76333786
604
 
#endif /* UNIV_DEBUG */
605
 
};
606
 
 
607
 
#ifndef UNIV_NONINL
608
 
#include "dict0mem.ic"
609
 
#endif
610
 
 
611
 
#endif