← Back to branch summary

~ubuntu-branches/ubuntu/precise/mysql-5.1/precise

« back to all changes in this revision

Viewing changes to storage/innodb_plugin/include/dict0dict.ic

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Tretkowski
  • Date: 2010-03-17 14:56:02 UTC
  • Revision ID: james.westby@ubuntu.com-20100317145602-x7e30l1b2sb5s6w6
Tags: upstream-5.1.45
Import upstream version 5.1.45

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innodb_plugin/include/dict0dict.ic
 
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., 59 Temple
 
15
Place, Suite 330, Boston, MA 02111-1307 USA
 
16
 
 
17
*****************************************************************************/
 
18
 
 
19
/******************************************************************//**
 
20
@file include/dict0dict.ic
 
21
Data dictionary system
 
22
 
 
23
Created 1/8/1996 Heikki Tuuri
 
24
***********************************************************************/
 
25
 
 
26
#include "data0type.h"
 
27
#ifndef UNIV_HOTBACKUP
 
28
#include "dict0load.h"
 
29
#include "rem0types.h"
 
30
 
 
31
/*********************************************************************//**
 
32
Gets the column data type. */
 
33
UNIV_INLINE
 
34
void
 
35
dict_col_copy_type(
 
36
/*===============*/
 
37
        const dict_col_t*       col,    /*!< in: column */
 
38
        dtype_t*                type)   /*!< out: data type */
 
39
{
 
40
        ut_ad(col && type);
 
41
 
 
42
        type->mtype = col->mtype;
 
43
        type->prtype = col->prtype;
 
44
        type->len = col->len;
 
45
        type->mbminlen = col->mbminlen;
 
46
        type->mbmaxlen = col->mbmaxlen;
 
47
}
 
48
#endif /* !UNIV_HOTBACKUP */
 
49
 
 
50
#ifdef UNIV_DEBUG
 
51
/*********************************************************************//**
 
52
Assert that a column and a data type match.
 
53
@return TRUE */
 
54
UNIV_INLINE
 
55
ibool
 
56
dict_col_type_assert_equal(
 
57
/*=======================*/
 
58
        const dict_col_t*       col,    /*!< in: column */
 
59
        const dtype_t*          type)   /*!< in: data type */
 
60
{
 
61
        ut_ad(col);
 
62
        ut_ad(type);
 
63
 
 
64
        ut_ad(col->mtype == type->mtype);
 
65
        ut_ad(col->prtype == type->prtype);
 
66
        ut_ad(col->len == type->len);
 
67
# ifndef UNIV_HOTBACKUP
 
68
        ut_ad(col->mbminlen == type->mbminlen);
 
69
        ut_ad(col->mbmaxlen == type->mbmaxlen);
 
70
# endif /* !UNIV_HOTBACKUP */
 
71
 
 
72
        return(TRUE);
 
73
}
 
74
#endif /* UNIV_DEBUG */
 
75
 
 
76
#ifndef UNIV_HOTBACKUP
 
77
/***********************************************************************//**
 
78
Returns the minimum size of the column.
 
79
@return minimum size */
 
80
UNIV_INLINE
 
81
ulint
 
82
dict_col_get_min_size(
 
83
/*==================*/
 
84
        const dict_col_t*       col)    /*!< in: column */
 
85
{
 
86
        return(dtype_get_min_size_low(col->mtype, col->prtype, col->len,
 
87
                                      col->mbminlen, col->mbmaxlen));
 
88
}
 
89
/***********************************************************************//**
 
90
Returns the maximum size of the column.
 
91
@return maximum size */
 
92
UNIV_INLINE
 
93
ulint
 
94
dict_col_get_max_size(
 
95
/*==================*/
 
96
        const dict_col_t*       col)    /*!< in: column */
 
97
{
 
98
        return(dtype_get_max_size_low(col->mtype, col->len));
 
99
}
 
100
#endif /* !UNIV_HOTBACKUP */
 
101
/***********************************************************************//**
 
102
Returns the size of a fixed size column, 0 if not a fixed size column.
 
103
@return fixed size, or 0 */
 
104
UNIV_INLINE
 
105
ulint
 
106
dict_col_get_fixed_size(
 
107
/*====================*/
 
108
        const dict_col_t*       col,    /*!< in: column */
 
109
        ulint                   comp)   /*!< in: nonzero=ROW_FORMAT=COMPACT  */
 
110
{
 
111
        return(dtype_get_fixed_size_low(col->mtype, col->prtype, col->len,
 
112
                                        col->mbminlen, col->mbmaxlen, comp));
 
113
}
 
114
/***********************************************************************//**
 
115
Returns the ROW_FORMAT=REDUNDANT stored SQL NULL size of a column.
 
116
For fixed length types it is the fixed length of the type, otherwise 0.
 
117
@return SQL null storage size in ROW_FORMAT=REDUNDANT */
 
118
UNIV_INLINE
 
119
ulint
 
120
dict_col_get_sql_null_size(
 
121
/*=======================*/
 
122
        const dict_col_t*       col,    /*!< in: column */
 
123
        ulint                   comp)   /*!< in: nonzero=ROW_FORMAT=COMPACT  */
 
124
{
 
125
        return(dict_col_get_fixed_size(col, comp));
 
126
}
 
127
 
 
128
/*********************************************************************//**
 
129
Gets the column number.
 
130
@return col->ind, table column position (starting from 0) */
 
131
UNIV_INLINE
 
132
ulint
 
133
dict_col_get_no(
 
134
/*============*/
 
135
        const dict_col_t*       col)    /*!< in: column */
 
136
{
 
137
        ut_ad(col);
 
138
 
 
139
        return(col->ind);
 
140
}
 
141
 
 
142
/*********************************************************************//**
 
143
Gets the column position in the clustered index. */
 
144
UNIV_INLINE
 
145
ulint
 
146
dict_col_get_clust_pos(
 
147
/*===================*/
 
148
        const dict_col_t*       col,            /*!< in: table column */
 
149
        const dict_index_t*     clust_index)    /*!< in: clustered index */
 
150
{
 
151
        ulint   i;
 
152
 
 
153
        ut_ad(col);
 
154
        ut_ad(clust_index);
 
155
        ut_ad(dict_index_is_clust(clust_index));
 
156
 
 
157
        for (i = 0; i < clust_index->n_def; i++) {
 
158
                const dict_field_t*     field = &clust_index->fields[i];
 
159
 
 
160
                if (!field->prefix_len && field->col == col) {
 
161
                        return(i);
 
162
                }
 
163
        }
 
164
 
 
165
        return(ULINT_UNDEFINED);
 
166
}
 
167
 
 
168
#ifndef UNIV_HOTBACKUP
 
169
#ifdef UNIV_DEBUG
 
170
/********************************************************************//**
 
171
Gets the first index on the table (the clustered index).
 
172
@return index, NULL if none exists */
 
173
UNIV_INLINE
 
174
dict_index_t*
 
175
dict_table_get_first_index(
 
176
/*=======================*/
 
177
        const dict_table_t*     table)  /*!< in: table */
 
178
{
 
179
        ut_ad(table);
 
180
        ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 
181
 
 
182
        return(UT_LIST_GET_FIRST(((dict_table_t*) table)->indexes));
 
183
}
 
184
 
 
185
/********************************************************************//**
 
186
Gets the next index on the table.
 
187
@return index, NULL if none left */
 
188
UNIV_INLINE
 
189
dict_index_t*
 
190
dict_table_get_next_index(
 
191
/*======================*/
 
192
        const dict_index_t*     index)  /*!< in: index */
 
193
{
 
194
        ut_ad(index);
 
195
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
196
 
 
197
        return(UT_LIST_GET_NEXT(indexes, (dict_index_t*) index));
 
198
}
 
199
#endif /* UNIV_DEBUG */
 
200
#endif /* !UNIV_HOTBACKUP */
 
201
 
 
202
/********************************************************************//**
 
203
Check whether the index is the clustered index.
 
204
@return nonzero for clustered index, zero for other indexes */
 
205
UNIV_INLINE
 
206
ulint
 
207
dict_index_is_clust(
 
208
/*================*/
 
209
        const dict_index_t*     index)  /*!< in: index */
 
210
{
 
211
        ut_ad(index);
 
212
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
213
 
 
214
        return(UNIV_UNLIKELY(index->type & DICT_CLUSTERED));
 
215
}
 
216
/********************************************************************//**
 
217
Check whether the index is unique.
 
218
@return nonzero for unique index, zero for other indexes */
 
219
UNIV_INLINE
 
220
ulint
 
221
dict_index_is_unique(
 
222
/*=================*/
 
223
        const dict_index_t*     index)  /*!< in: index */
 
224
{
 
225
        ut_ad(index);
 
226
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
227
 
 
228
        return(UNIV_UNLIKELY(index->type & DICT_UNIQUE));
 
229
}
 
230
 
 
231
/********************************************************************//**
 
232
Check whether the index is the insert buffer tree.
 
233
@return nonzero for insert buffer, zero for other indexes */
 
234
UNIV_INLINE
 
235
ulint
 
236
dict_index_is_ibuf(
 
237
/*===============*/
 
238
        const dict_index_t*     index)  /*!< in: index */
 
239
{
 
240
        ut_ad(index);
 
241
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
242
 
 
243
        return(UNIV_UNLIKELY(index->type & DICT_IBUF));
 
244
}
 
245
 
 
246
/********************************************************************//**
 
247
Check whether the index is a secondary index or the insert buffer tree.
 
248
@return nonzero for insert buffer, zero for other indexes */
 
249
UNIV_INLINE
 
250
ulint
 
251
dict_index_is_sec_or_ibuf(
 
252
/*======================*/
 
253
        const dict_index_t*     index)  /*!< in: index */
 
254
{
 
255
        ulint   type;
 
256
 
 
257
        ut_ad(index);
 
258
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
259
 
 
260
        type = index->type;
 
261
 
 
262
        return(UNIV_LIKELY(!(type & DICT_CLUSTERED) || (type & DICT_IBUF)));
 
263
}
 
264
 
 
265
/********************************************************************//**
 
266
Gets the number of user-defined columns in a table in the dictionary
 
267
cache.
 
268
@return number of user-defined (e.g., not ROW_ID) columns of a table */
 
269
UNIV_INLINE
 
270
ulint
 
271
dict_table_get_n_user_cols(
 
272
/*=======================*/
 
273
        const dict_table_t*     table)  /*!< in: table */
 
274
{
 
275
        ut_ad(table);
 
276
        ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 
277
 
 
278
        return(table->n_cols - DATA_N_SYS_COLS);
 
279
}
 
280
 
 
281
/********************************************************************//**
 
282
Gets the number of system columns in a table in the dictionary cache.
 
283
@return number of system (e.g., ROW_ID) columns of a table */
 
284
UNIV_INLINE
 
285
ulint
 
286
dict_table_get_n_sys_cols(
 
287
/*======================*/
 
288
        const dict_table_t*     table __attribute__((unused)))  /*!< in: table */
 
289
{
 
290
        ut_ad(table);
 
291
        ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 
292
        ut_ad(table->cached);
 
293
 
 
294
        return(DATA_N_SYS_COLS);
 
295
}
 
296
 
 
297
/********************************************************************//**
 
298
Gets the number of all columns (also system) in a table in the dictionary
 
299
cache.
 
300
@return number of columns of a table */
 
301
UNIV_INLINE
 
302
ulint
 
303
dict_table_get_n_cols(
 
304
/*==================*/
 
305
        const dict_table_t*     table)  /*!< in: table */
 
306
{
 
307
        ut_ad(table);
 
308
        ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 
309
 
 
310
        return(table->n_cols);
 
311
}
 
312
 
 
313
#ifdef UNIV_DEBUG
 
314
/********************************************************************//**
 
315
Gets the nth column of a table.
 
316
@return pointer to column object */
 
317
UNIV_INLINE
 
318
dict_col_t*
 
319
dict_table_get_nth_col(
 
320
/*===================*/
 
321
        const dict_table_t*     table,  /*!< in: table */
 
322
        ulint                   pos)    /*!< in: position of column */
 
323
{
 
324
        ut_ad(table);
 
325
        ut_ad(pos < table->n_def);
 
326
        ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 
327
 
 
328
        return((dict_col_t*) (table->cols) + pos);
 
329
}
 
330
 
 
331
/********************************************************************//**
 
332
Gets the given system column of a table.
 
333
@return pointer to column object */
 
334
UNIV_INLINE
 
335
dict_col_t*
 
336
dict_table_get_sys_col(
 
337
/*===================*/
 
338
        const dict_table_t*     table,  /*!< in: table */
 
339
        ulint                   sys)    /*!< in: DATA_ROW_ID, ... */
 
340
{
 
341
        dict_col_t*     col;
 
342
 
 
343
        ut_ad(table);
 
344
        ut_ad(sys < DATA_N_SYS_COLS);
 
345
        ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 
346
 
 
347
        col = dict_table_get_nth_col(table, table->n_cols
 
348
                                     - DATA_N_SYS_COLS + sys);
 
349
        ut_ad(col->mtype == DATA_SYS);
 
350
        ut_ad(col->prtype == (sys | DATA_NOT_NULL));
 
351
 
 
352
        return(col);
 
353
}
 
354
#endif /* UNIV_DEBUG */
 
355
 
 
356
/********************************************************************//**
 
357
Gets the given system column number of a table.
 
358
@return column number */
 
359
UNIV_INLINE
 
360
ulint
 
361
dict_table_get_sys_col_no(
 
362
/*======================*/
 
363
        const dict_table_t*     table,  /*!< in: table */
 
364
        ulint                   sys)    /*!< in: DATA_ROW_ID, ... */
 
365
{
 
366
        ut_ad(table);
 
367
        ut_ad(sys < DATA_N_SYS_COLS);
 
368
        ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
 
369
 
 
370
        return(table->n_cols - DATA_N_SYS_COLS + sys);
 
371
}
 
372
 
 
373
/********************************************************************//**
 
374
Check whether the table uses the compact page format.
 
375
@return TRUE if table uses the compact page format */
 
376
UNIV_INLINE
 
377
ibool
 
378
dict_table_is_comp(
 
379
/*===============*/
 
380
        const dict_table_t*     table)  /*!< in: table */
 
381
{
 
382
        ut_ad(table);
 
383
 
 
384
#if DICT_TF_COMPACT != TRUE
 
385
#error
 
386
#endif
 
387
 
 
388
        return(UNIV_LIKELY(table->flags & DICT_TF_COMPACT));
 
389
}
 
390
 
 
391
/********************************************************************//**
 
392
Determine the file format of a table.
 
393
@return file format version */
 
394
UNIV_INLINE
 
395
ulint
 
396
dict_table_get_format(
 
397
/*==================*/
 
398
        const dict_table_t*     table)  /*!< in: table */
 
399
{
 
400
        ut_ad(table);
 
401
 
 
402
        return((table->flags & DICT_TF_FORMAT_MASK) >> DICT_TF_FORMAT_SHIFT);
 
403
}
 
404
 
 
405
/********************************************************************//**
 
406
Determine the file format of a table. */
 
407
UNIV_INLINE
 
408
void
 
409
dict_table_set_format(
 
410
/*==================*/
 
411
        dict_table_t*   table,  /*!< in/out: table */
 
412
        ulint           format) /*!< in: file format version */
 
413
{
 
414
        ut_ad(table);
 
415
 
 
416
        table->flags = (table->flags & ~DICT_TF_FORMAT_MASK)
 
417
                | (format << DICT_TF_FORMAT_SHIFT);
 
418
}
 
419
 
 
420
/********************************************************************//**
 
421
Extract the compressed page size from table flags.
 
422
@return compressed page size, or 0 if not compressed */
 
423
UNIV_INLINE
 
424
ulint
 
425
dict_table_flags_to_zip_size(
 
426
/*=========================*/
 
427
        ulint   flags)  /*!< in: flags */
 
428
{
 
429
        ulint   zip_size = flags & DICT_TF_ZSSIZE_MASK;
 
430
 
 
431
        if (UNIV_UNLIKELY(zip_size)) {
 
432
                zip_size = ((PAGE_ZIP_MIN_SIZE >> 1)
 
433
                         << (zip_size >> DICT_TF_ZSSIZE_SHIFT));
 
434
 
 
435
                ut_ad(zip_size <= UNIV_PAGE_SIZE);
 
436
        }
 
437
 
 
438
        return(zip_size);
 
439
}
 
440
 
 
441
/********************************************************************//**
 
442
Check whether the table uses the compressed compact page format.
 
443
@return compressed page size, or 0 if not compressed */
 
444
UNIV_INLINE
 
445
ulint
 
446
dict_table_zip_size(
 
447
/*================*/
 
448
        const dict_table_t*     table)  /*!< in: table */
 
449
{
 
450
        ut_ad(table);
 
451
 
 
452
        return(dict_table_flags_to_zip_size(table->flags));
 
453
}
 
454
 
 
455
/********************************************************************//**
 
456
Gets the number of fields in the internal representation of an index,
 
457
including fields added by the dictionary system.
 
458
@return number of fields */
 
459
UNIV_INLINE
 
460
ulint
 
461
dict_index_get_n_fields(
 
462
/*====================*/
 
463
        const dict_index_t*     index)  /*!< in: an internal
 
464
                                        representation of index (in
 
465
                                        the dictionary cache) */
 
466
{
 
467
        ut_ad(index);
 
468
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
469
 
 
470
        return(index->n_fields);
 
471
}
 
472
 
 
473
/********************************************************************//**
 
474
Gets the number of fields in the internal representation of an index
 
475
that uniquely determine the position of an index entry in the index, if
 
476
we do not take multiversioning into account: in the B-tree use the value
 
477
returned by dict_index_get_n_unique_in_tree.
 
478
@return number of fields */
 
479
UNIV_INLINE
 
480
ulint
 
481
dict_index_get_n_unique(
 
482
/*====================*/
 
483
        const dict_index_t*     index)  /*!< in: an internal representation
 
484
                                        of index (in the dictionary cache) */
 
485
{
 
486
        ut_ad(index);
 
487
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
488
        ut_ad(index->cached);
 
489
 
 
490
        return(index->n_uniq);
 
491
}
 
492
 
 
493
/********************************************************************//**
 
494
Gets the number of fields in the internal representation of an index
 
495
which uniquely determine the position of an index entry in the index, if
 
496
we also take multiversioning into account.
 
497
@return number of fields */
 
498
UNIV_INLINE
 
499
ulint
 
500
dict_index_get_n_unique_in_tree(
 
501
/*============================*/
 
502
        const dict_index_t*     index)  /*!< in: an internal representation
 
503
                                        of index (in the dictionary cache) */
 
504
{
 
505
        ut_ad(index);
 
506
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
507
        ut_ad(index->cached);
 
508
 
 
509
        if (dict_index_is_clust(index)) {
 
510
 
 
511
                return(dict_index_get_n_unique(index));
 
512
        }
 
513
 
 
514
        return(dict_index_get_n_fields(index));
 
515
}
 
516
 
 
517
/********************************************************************//**
 
518
Gets the number of user-defined ordering fields in the index. In the internal
 
519
representation of clustered indexes we add the row id to the ordering fields
 
520
to make a clustered index unique, but this function returns the number of
 
521
fields the user defined in the index as ordering fields.
 
522
@return number of fields */
 
523
UNIV_INLINE
 
524
ulint
 
525
dict_index_get_n_ordering_defined_by_user(
 
526
/*======================================*/
 
527
        const dict_index_t*     index)  /*!< in: an internal representation
 
528
                                        of index (in the dictionary cache) */
 
529
{
 
530
        return(index->n_user_defined_cols);
 
531
}
 
532
 
 
533
#ifdef UNIV_DEBUG
 
534
/********************************************************************//**
 
535
Gets the nth field of an index.
 
536
@return pointer to field object */
 
537
UNIV_INLINE
 
538
dict_field_t*
 
539
dict_index_get_nth_field(
 
540
/*=====================*/
 
541
        const dict_index_t*     index,  /*!< in: index */
 
542
        ulint                   pos)    /*!< in: position of field */
 
543
{
 
544
        ut_ad(index);
 
545
        ut_ad(pos < index->n_def);
 
546
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
547
 
 
548
        return((dict_field_t*) (index->fields) + pos);
 
549
}
 
550
#endif /* UNIV_DEBUG */
 
551
 
 
552
/********************************************************************//**
 
553
Returns the position of a system column in an index.
 
554
@return position, ULINT_UNDEFINED if not contained */
 
555
UNIV_INLINE
 
556
ulint
 
557
dict_index_get_sys_col_pos(
 
558
/*=======================*/
 
559
        const dict_index_t*     index,  /*!< in: index */
 
560
        ulint                   type)   /*!< in: DATA_ROW_ID, ... */
 
561
{
 
562
        ut_ad(index);
 
563
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
564
        ut_ad(!(index->type & DICT_UNIVERSAL));
 
565
 
 
566
        if (dict_index_is_clust(index)) {
 
567
 
 
568
                return(dict_col_get_clust_pos(
 
569
                               dict_table_get_sys_col(index->table, type),
 
570
                               index));
 
571
        }
 
572
 
 
573
        return(dict_index_get_nth_col_pos(
 
574
                       index, dict_table_get_sys_col_no(index->table, type)));
 
575
}
 
576
 
 
577
/*********************************************************************//**
 
578
Gets the field column.
 
579
@return field->col, pointer to the table column */
 
580
UNIV_INLINE
 
581
const dict_col_t*
 
582
dict_field_get_col(
 
583
/*===============*/
 
584
        const dict_field_t*     field)  /*!< in: index field */
 
585
{
 
586
        ut_ad(field);
 
587
 
 
588
        return(field->col);
 
589
}
 
590
 
 
591
/********************************************************************//**
 
592
Gets pointer to the nth column in an index.
 
593
@return column */
 
594
UNIV_INLINE
 
595
const dict_col_t*
 
596
dict_index_get_nth_col(
 
597
/*===================*/
 
598
        const dict_index_t*     index,  /*!< in: index */
 
599
        ulint                   pos)    /*!< in: position of the field */
 
600
{
 
601
        return(dict_field_get_col(dict_index_get_nth_field(index, pos)));
 
602
}
 
603
 
 
604
/********************************************************************//**
 
605
Gets the column number the nth field in an index.
 
606
@return column number */
 
607
UNIV_INLINE
 
608
ulint
 
609
dict_index_get_nth_col_no(
 
610
/*======================*/
 
611
        const dict_index_t*     index,  /*!< in: index */
 
612
        ulint                   pos)    /*!< in: position of the field */
 
613
{
 
614
        return(dict_col_get_no(dict_index_get_nth_col(index, pos)));
 
615
}
 
616
 
 
617
#ifndef UNIV_HOTBACKUP
 
618
/********************************************************************//**
 
619
Returns the minimum data size of an index record.
 
620
@return minimum data size in bytes */
 
621
UNIV_INLINE
 
622
ulint
 
623
dict_index_get_min_size(
 
624
/*====================*/
 
625
        const dict_index_t*     index)  /*!< in: index */
 
626
{
 
627
        ulint   n       = dict_index_get_n_fields(index);
 
628
        ulint   size    = 0;
 
629
 
 
630
        while (n--) {
 
631
                size += dict_col_get_min_size(dict_index_get_nth_col(index,
 
632
                                                                     n));
 
633
        }
 
634
 
 
635
        return(size);
 
636
}
 
637
 
 
638
/*********************************************************************//**
 
639
Gets the space id of the root of the index tree.
 
640
@return space id */
 
641
UNIV_INLINE
 
642
ulint
 
643
dict_index_get_space(
 
644
/*=================*/
 
645
        const dict_index_t*     index)  /*!< in: index */
 
646
{
 
647
        ut_ad(index);
 
648
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
649
 
 
650
        return(index->space);
 
651
}
 
652
 
 
653
/*********************************************************************//**
 
654
Sets the space id of the root of the index tree. */
 
655
UNIV_INLINE
 
656
void
 
657
dict_index_set_space(
 
658
/*=================*/
 
659
        dict_index_t*   index,  /*!< in/out: index */
 
660
        ulint           space)  /*!< in: space id */
 
661
{
 
662
        ut_ad(index);
 
663
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
664
 
 
665
        index->space = space;
 
666
}
 
667
 
 
668
/*********************************************************************//**
 
669
Gets the page number of the root of the index tree.
 
670
@return page number */
 
671
UNIV_INLINE
 
672
ulint
 
673
dict_index_get_page(
 
674
/*================*/
 
675
        const dict_index_t*     index)  /*!< in: index */
 
676
{
 
677
        ut_ad(index);
 
678
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
679
 
 
680
        return(index->page);
 
681
}
 
682
 
 
683
/*********************************************************************//**
 
684
Sets the page number of the root of index tree. */
 
685
UNIV_INLINE
 
686
void
 
687
dict_index_set_page(
 
688
/*================*/
 
689
        dict_index_t*   index,  /*!< in/out: index */
 
690
        ulint           page)   /*!< in: page number */
 
691
{
 
692
        ut_ad(index);
 
693
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
694
 
 
695
        index->page = page;
 
696
}
 
697
 
 
698
/*********************************************************************//**
 
699
Gets the read-write lock of the index tree.
 
700
@return read-write lock */
 
701
UNIV_INLINE
 
702
rw_lock_t*
 
703
dict_index_get_lock(
 
704
/*================*/
 
705
        dict_index_t*   index)  /*!< in: index */
 
706
{
 
707
        ut_ad(index);
 
708
        ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
 
709
 
 
710
        return(&(index->lock));
 
711
}
 
712
 
 
713
/********************************************************************//**
 
714
Returns free space reserved for future updates of records. This is
 
715
relevant only in the case of many consecutive inserts, as updates
 
716
which make the records bigger might fragment the index.
 
717
@return number of free bytes on page, reserved for updates */
 
718
UNIV_INLINE
 
719
ulint
 
720
dict_index_get_space_reserve(void)
 
721
/*==============================*/
 
722
{
 
723
        return(UNIV_PAGE_SIZE / 16);
 
724
}
 
725
 
 
726
/**********************************************************************//**
 
727
Checks if a table is in the dictionary cache.
 
728
@return table, NULL if not found */
 
729
UNIV_INLINE
 
730
dict_table_t*
 
731
dict_table_check_if_in_cache_low(
 
732
/*=============================*/
 
733
        const char*     table_name)     /*!< in: table name */
 
734
{
 
735
        dict_table_t*   table;
 
736
        ulint           table_fold;
 
737
 
 
738
        ut_ad(table_name);
 
739
        ut_ad(mutex_own(&(dict_sys->mutex)));
 
740
 
 
741
        /* Look for the table name in the hash table */
 
742
        table_fold = ut_fold_string(table_name);
 
743
 
 
744
        HASH_SEARCH(name_hash, dict_sys->table_hash, table_fold,
 
745
                    dict_table_t*, table, ut_ad(table->cached),
 
746
                    !strcmp(table->name, table_name));
 
747
        return(table);
 
748
}
 
749
 
 
750
/**********************************************************************//**
 
751
Gets a table; loads it to the dictionary cache if necessary. A low-level
 
752
function.
 
753
@return table, NULL if not found */
 
754
UNIV_INLINE
 
755
dict_table_t*
 
756
dict_table_get_low(
 
757
/*===============*/
 
758
        const char*     table_name)     /*!< in: table name */
 
759
{
 
760
        dict_table_t*   table;
 
761
 
 
762
        ut_ad(table_name);
 
763
        ut_ad(mutex_own(&(dict_sys->mutex)));
 
764
 
 
765
        table = dict_table_check_if_in_cache_low(table_name);
 
766
 
 
767
        if (table == NULL) {
 
768
                table = dict_load_table(table_name);
 
769
        }
 
770
 
 
771
        ut_ad(!table || table->cached);
 
772
 
 
773
        return(table);
 
774
}
 
775
 
 
776
/**********************************************************************//**
 
777
Returns a table object based on table id.
 
778
@return table, NULL if does not exist */
 
779
UNIV_INLINE
 
780
dict_table_t*
 
781
dict_table_get_on_id_low(
 
782
/*=====================*/
 
783
        dulint  table_id)       /*!< in: table id */
 
784
{
 
785
        dict_table_t*   table;
 
786
        ulint           fold;
 
787
 
 
788
        ut_ad(mutex_own(&(dict_sys->mutex)));
 
789
 
 
790
        /* Look for the table name in the hash table */
 
791
        fold = ut_fold_dulint(table_id);
 
792
 
 
793
        HASH_SEARCH(id_hash, dict_sys->table_id_hash, fold,
 
794
                    dict_table_t*, table, ut_ad(table->cached),
 
795
                    !ut_dulint_cmp(table->id, table_id));
 
796
        if (table == NULL) {
 
797
                table = dict_load_table_on_id(table_id);
 
798
        }
 
799
 
 
800
        ut_ad(!table || table->cached);
 
801
 
 
802
        /* TODO: should get the type information from MySQL */
 
803
 
 
804
        return(table);
 
805
}
 
806
#endif /* !UNIV_HOTBACKUP */