← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Stewart Smith
  • Author(s): Marko Mäkelä
  • Date: 2010-12-20 03:21:44 UTC
  • mto: (2021.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 2022.
  • Revision ID: stewart@flamingspork.com-20101220032144-7aqh2z403u7d7bdp
Merge Revision revid:marko.makela@oracle.com-20101104131215-pfxnpidlrzd4krg0 from MySQL InnoDB

Original revid:marko.makela@oracle.com-20101104131215-pfxnpidlrzd4krg0

Original Authors: Marko Mäkelä <marko.makela@oracle.com>
Original commit message:
row_ins_index_entry(): Note that only CREATE INDEX sets foreign=FALSE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/dict0load.h
 
1
/*****************************************************************************
 
2
 
 
3
Copyright (c) 1996, 2009, 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/dict0load.h
 
21
Loads to the memory cache database object definitions
 
22
from dictionary tables
 
23
 
 
24
Created 4/24/1996 Heikki Tuuri
 
25
*******************************************************/
 
26
 
 
27
#ifndef dict0load_h
 
28
#define dict0load_h
 
29
 
 
30
#include "univ.i"
 
31
#include "dict0types.h"
 
32
#include "ut0byte.h"
 
33
#include "mem0mem.h"
 
34
#include "btr0types.h"
 
35
 
 
36
/** enum that defines all 6 system table IDs */
 
37
enum dict_system_table_id {
 
38
        SYS_TABLES = 0,
 
39
        SYS_INDEXES,
 
40
        SYS_COLUMNS,
 
41
        SYS_FIELDS,
 
42
        SYS_FOREIGN,
 
43
        SYS_FOREIGN_COLS,
 
44
 
 
45
        /* This must be last item. Defines the number of system tables. */
 
46
        SYS_NUM_SYSTEM_TABLES
 
47
};
 
48
 
 
49
typedef enum dict_system_table_id       dict_system_id_t;
 
50
 
 
51
/** Status bit for dict_process_sys_tables_rec() */
 
52
enum dict_table_info {
 
53
        DICT_TABLE_LOAD_FROM_RECORD = 0,/*!< Directly populate a dict_table_t
 
54
                                        structure with information from
 
55
                                        a SYS_TABLES record */
 
56
        DICT_TABLE_LOAD_FROM_CACHE = 1, /*!< Check first whether dict_table_t
 
57
                                        is in the cache, if so, return it */
 
58
        DICT_TABLE_UPDATE_STATS = 2     /*!< whether to update statistics
 
59
                                        when loading SYS_TABLES information. */
 
60
};
 
61
 
 
62
typedef enum dict_table_info    dict_table_info_t;
 
63
 
 
64
/********************************************************************//**
 
65
In a crash recovery we already have all the tablespace objects created.
 
66
This function compares the space id information in the InnoDB data dictionary
 
67
to what we already read with fil_load_single_table_tablespaces().
 
68
 
 
69
In a normal startup, we create the tablespace objects for every table in
 
70
InnoDB's data dictionary, if the corresponding .ibd file exists.
 
71
We also scan the biggest space id, and store it to fil_system. */
 
72
UNIV_INTERN
 
73
void
 
74
dict_check_tablespaces_and_store_max_id(
 
75
/*====================================*/
 
76
        ibool   in_crash_recovery);     /*!< in: are we doing a crash recovery */
 
77
/********************************************************************//**
 
78
Finds the first table name in the given database.
 
79
@return own: table name, NULL if does not exist; the caller must free
 
80
the memory in the string! */
 
81
UNIV_INTERN
 
82
char*
 
83
dict_get_first_table_name_in_db(
 
84
/*============================*/
 
85
        const char*     name);  /*!< in: database name which ends to '/' */
 
86
 
 
87
/********************************************************************//**
 
88
Loads a table definition from a SYS_TABLES record to dict_table_t.
 
89
Does not load any columns or indexes.
 
90
@return error message, or NULL on success */
 
91
UNIV_INTERN
 
92
const char*
 
93
dict_load_table_low(
 
94
/*================*/
 
95
        const char*     name,           /*!< in: table name */
 
96
        const rec_t*    rec,            /*!< in: SYS_TABLES record */
 
97
        dict_table_t**  table);         /*!< out,own: table, or NULL */
 
98
/********************************************************************//**
 
99
Loads a table column definition from a SYS_COLUMNS record to
 
100
dict_table_t.
 
101
@return error message, or NULL on success */
 
102
UNIV_INTERN
 
103
const char*
 
104
dict_load_column_low(
 
105
/*=================*/
 
106
        dict_table_t*   table,          /*!< in/out: table, could be NULL
 
107
                                        if we just populate a dict_column_t
 
108
                                        struct with information from
 
109
                                        a SYS_COLUMNS record */
 
110
        mem_heap_t*     heap,           /*!< in/out: memory heap
 
111
                                        for temporary storage */
 
112
        dict_col_t*     column,         /*!< out: dict_column_t to fill,
 
113
                                        or NULL if table != NULL */
 
114
        table_id_t*     table_id,       /*!< out: table id */
 
115
        const char**    col_name,       /*!< out: column name */
 
116
        const rec_t*    rec);           /*!< in: SYS_COLUMNS record */
 
117
/********************************************************************//**
 
118
Loads an index definition from a SYS_INDEXES record to dict_index_t.
 
119
If allocate=TRUE, we will create a dict_index_t structure and fill it
 
120
accordingly. If allocated=FALSE, the dict_index_t will be supplied by
 
121
the caller and filled with information read from the record.  @return
 
122
error message, or NULL on success */
 
123
UNIV_INTERN
 
124
const char*
 
125
dict_load_index_low(
 
126
/*================*/
 
127
        byte*           table_id,       /*!< in/out: table id (8 bytes),
 
128
                                        an "in" value if allocate=TRUE
 
129
                                        and "out" when allocate=FALSE */
 
130
        const char*     table_name,     /*!< in: table name */
 
131
        mem_heap_t*     heap,           /*!< in/out: temporary memory heap */
 
132
        const rec_t*    rec,            /*!< in: SYS_INDEXES record */
 
133
        ibool           allocate,       /*!< in: TRUE=allocate *index,
 
134
                                        FALSE=fill in a pre-allocated
 
135
                                        *index */
 
136
        dict_index_t**  index);         /*!< out,own: index, or NULL */
 
137
/********************************************************************//**
 
138
Loads an index field definition from a SYS_FIELDS record to
 
139
dict_index_t.
 
140
@return error message, or NULL on success */
 
141
UNIV_INTERN
 
142
const char*
 
143
dict_load_field_low(
 
144
/*================*/
 
145
        byte*           index_id,       /*!< in/out: index id (8 bytes)
 
146
                                        an "in" value if index != NULL
 
147
                                        and "out" if index == NULL */
 
148
        dict_index_t*   index,          /*!< in/out: index, could be NULL
 
149
                                        if we just populate a dict_field_t
 
150
                                        struct with information from
 
151
                                        a SYS_FIELDS record */
 
152
        dict_field_t*   sys_field,      /*!< out: dict_field_t to be
 
153
                                        filled */
 
154
        ulint*          pos,            /*!< out: Field position */
 
155
        byte*           last_index_id,  /*!< in: last index id */
 
156
        mem_heap_t*     heap,           /*!< in/out: memory heap
 
157
                                        for temporary storage */
 
158
        const rec_t*    rec);           /*!< in: SYS_FIELDS record */
 
159
/********************************************************************//**
 
160
Loads a table definition and also all its index definitions, and also
 
161
the cluster definition if the table is a member in a cluster. Also loads
 
162
all foreign key constraints where the foreign key is in the table or where
 
163
a foreign key references columns in this table.
 
164
@return table, NULL if does not exist; if the table is stored in an
 
165
.ibd file, but the file does not exist, then we set the
 
166
ibd_file_missing flag TRUE in the table object we return */
 
167
UNIV_INTERN
 
168
dict_table_t*
 
169
dict_load_table(
 
170
/*============*/
 
171
        const char*     name,   /*!< in: table name in the
 
172
                                databasename/tablename format */
 
173
        ibool           cached);/*!< in: TRUE=add to cache, FALSE=do not */
 
174
/***********************************************************************//**
 
175
Loads a table object based on the table id.
 
176
@return table; NULL if table does not exist */
 
177
UNIV_INTERN
 
178
dict_table_t*
 
179
dict_load_table_on_id(
 
180
/*==================*/
 
181
        table_id_t      table_id);      /*!< in: table id */
 
182
/********************************************************************//**
 
183
This function is called when the database is booted.
 
184
Loads system table index definitions except for the clustered index which
 
185
is added to the dictionary cache at booting before calling this function. */
 
186
UNIV_INTERN
 
187
void
 
188
dict_load_sys_table(
 
189
/*================*/
 
190
        dict_table_t*   table); /*!< in: system table */
 
191
/***********************************************************************//**
 
192
Loads foreign key constraints where the table is either the foreign key
 
193
holder or where the table is referenced by a foreign key. Adds these
 
194
constraints to the data dictionary. Note that we know that the dictionary
 
195
cache already contains all constraints where the other relevant table is
 
196
already in the dictionary cache.
 
197
@return DB_SUCCESS or error code */
 
198
UNIV_INTERN
 
199
ulint
 
200
dict_load_foreigns(
 
201
/*===============*/
 
202
        const char*     table_name,     /*!< in: table name */
 
203
        ibool           check_recursive,/*!< in: Whether to check recursive
 
204
                                        load of tables chained by FK */
 
205
        ibool           check_charsets);/*!< in: TRUE=check charsets
 
206
                                        compatibility */
 
207
/********************************************************************//**
 
208
Prints to the standard output information on all tables found in the data
 
209
dictionary system table. */
 
210
UNIV_INTERN
 
211
void
 
212
dict_print(void);
 
213
/*============*/
 
214
 
 
215
typedef void (*dict_print_callback)(void *ptr, const char *);
 
216
UNIV_INTERN void dict_print_with_callback(dict_print_callback, void *);
 
217
 
 
218
 
 
219
/********************************************************************//**
 
220
This function opens a system table, and return the first record.
 
221
@return first record of the system table */
 
222
UNIV_INTERN
 
223
const rec_t*
 
224
dict_startscan_system(
 
225
/*==================*/
 
226
        btr_pcur_t*     pcur,           /*!< out: persistent cursor to
 
227
                                        the record */
 
228
        mtr_t*          mtr,            /*!< in: the mini-transaction */
 
229
        dict_system_id_t system_id);    /*!< in: which system table to open */
 
230
/********************************************************************//**
 
231
This function get the next system table record as we scan the table.
 
232
@return the record if found, NULL if end of scan. */
 
233
UNIV_INTERN
 
234
const rec_t*
 
235
dict_getnext_system(
 
236
/*================*/
 
237
        btr_pcur_t*     pcur,           /*!< in/out: persistent cursor
 
238
                                        to the record */
 
239
        mtr_t*          mtr);           /*!< in: the mini-transaction */
 
240
/********************************************************************//**
 
241
This function processes one SYS_TABLES record and populate the dict_table_t
 
242
struct for the table. Extracted out of dict_print() to be used by
 
243
both monitor table output and information schema innodb_sys_tables output.
 
244
@return error message, or NULL on success */
 
245
UNIV_INTERN
 
246
const char*
 
247
dict_process_sys_tables_rec(
 
248
/*========================*/
 
249
        mem_heap_t*     heap,           /*!< in: temporary memory heap */
 
250
        const rec_t*    rec,            /*!< in: SYS_TABLES record */
 
251
        dict_table_t**  table,          /*!< out: dict_table_t to fill */
 
252
        dict_table_info_t status);      /*!< in: status bit controls
 
253
                                        options such as whether we shall
 
254
                                        look for dict_table_t from cache
 
255
                                        first */
 
256
/********************************************************************//**
 
257
This function parses a SYS_INDEXES record and populate a dict_index_t
 
258
structure with the information from the record. For detail information
 
259
about SYS_INDEXES fields, please refer to dict_boot() function.
 
260
@return error message, or NULL on success */
 
261
UNIV_INTERN
 
262
const char*
 
263
dict_process_sys_indexes_rec(
 
264
/*=========================*/
 
265
        mem_heap_t*     heap,           /*!< in/out: heap memory */
 
266
        const rec_t*    rec,            /*!< in: current SYS_INDEXES rec */
 
267
        dict_index_t*   index,          /*!< out: dict_index_t to be
 
268
                                        filled */
 
269
        table_id_t*     table_id);      /*!< out: table id */
 
270
/********************************************************************//**
 
271
This function parses a SYS_COLUMNS record and populate a dict_column_t
 
272
structure with the information from the record.
 
273
@return error message, or NULL on success */
 
274
UNIV_INTERN
 
275
const char*
 
276
dict_process_sys_columns_rec(
 
277
/*=========================*/
 
278
        mem_heap_t*     heap,           /*!< in/out: heap memory */
 
279
        const rec_t*    rec,            /*!< in: current SYS_COLUMNS rec */
 
280
        dict_col_t*     column,         /*!< out: dict_col_t to be filled */
 
281
        table_id_t*     table_id,       /*!< out: table id */
 
282
        const char**    col_name);      /*!< out: column name */
 
283
/********************************************************************//**
 
284
This function parses a SYS_FIELDS record and populate a dict_field_t
 
285
structure with the information from the record.
 
286
@return error message, or NULL on success */
 
287
UNIV_INTERN
 
288
const char*
 
289
dict_process_sys_fields_rec(
 
290
/*========================*/
 
291
        mem_heap_t*     heap,           /*!< in/out: heap memory */
 
292
        const rec_t*    rec,            /*!< in: current SYS_FIELDS rec */
 
293
        dict_field_t*   sys_field,      /*!< out: dict_field_t to be
 
294
                                        filled */
 
295
        ulint*          pos,            /*!< out: Field position */
 
296
        index_id_t*     index_id,       /*!< out: current index id */
 
297
        index_id_t      last_id);       /*!< in: previous index id */
 
298
/********************************************************************//**
 
299
This function parses a SYS_FOREIGN record and populate a dict_foreign_t
 
300
structure with the information from the record. For detail information
 
301
about SYS_FOREIGN fields, please refer to dict_load_foreign() function
 
302
@return error message, or NULL on success */
 
303
UNIV_INTERN
 
304
const char*
 
305
dict_process_sys_foreign_rec(
 
306
/*=========================*/
 
307
        mem_heap_t*     heap,           /*!< in/out: heap memory */
 
308
        const rec_t*    rec,            /*!< in: current SYS_FOREIGN rec */
 
309
        dict_foreign_t* foreign);       /*!< out: dict_foreign_t to be
 
310
                                        filled */
 
311
/********************************************************************//**
 
312
This function parses a SYS_FOREIGN_COLS record and extract necessary
 
313
information from the record and return to caller.
 
314
@return error message, or NULL on success */
 
315
UNIV_INTERN
 
316
const char*
 
317
dict_process_sys_foreign_col_rec(
 
318
/*=============================*/
 
319
        mem_heap_t*     heap,           /*!< in/out: heap memory */
 
320
        const rec_t*    rec,            /*!< in: current SYS_FOREIGN_COLS rec */
 
321
        const char**    name,           /*!< out: foreign key constraint name */
 
322
        const char**    for_col_name,   /*!< out: referencing column name */
 
323
        const char**    ref_col_name,   /*!< out: referenced column name
 
324
                                        in referenced table */
 
325
        ulint*          pos);           /*!< out: column position */
 
326
#ifndef UNIV_NONINL
 
327
#include "dict0load.ic"
 
328
#endif
 
329
 
 
330
#endif