← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/btr0btr.ic

  • Committer: Padraig O'Sullivan
  • Date: 2009-09-13 00:53:34 UTC
  • mto: (1126.9.2 captain-20090915-01)
  • mto: This revision was merged to the branch mainline in revision 1133.
  • Revision ID: osullivan.padraig@gmail.com-20090913005334-6wio2sbjugskfbm3
Added calls to the connection start/end dtrace probes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/btr0btr.ic
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (c) 1994, 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/btr0btr.ic
21
 
The B-tree
22
 
 
23
 
Created 6/2/1994 Heikki Tuuri
24
 
*******************************************************/
25
 
 
26
 
#include "mach0data.h"
27
 
#ifndef UNIV_HOTBACKUP
28
 
#include "mtr0mtr.h"
29
 
#include "mtr0log.h"
30
 
#include "page0zip.h"
31
 
 
32
 
#define BTR_MAX_NODE_LEVEL      50      /*!< Maximum B-tree page level
33
 
                                        (not really a hard limit).
34
 
                                        Used in debug assertions
35
 
                                        in btr_page_set_level and
36
 
                                        btr_page_get_level_low */
37
 
 
38
 
/**************************************************************//**
39
 
Gets a buffer page and declares its latching order level. */
40
 
UNIV_INLINE
41
 
buf_block_t*
42
 
btr_block_get(
43
 
/*==========*/
44
 
        ulint   space,          /*!< in: space id */
45
 
        ulint   zip_size,       /*!< in: compressed page size in bytes
46
 
                                or 0 for uncompressed pages */
47
 
        ulint   page_no,        /*!< in: page number */
48
 
        ulint   mode,           /*!< in: latch mode */
49
 
        mtr_t*  mtr)            /*!< in: mtr */
50
 
{
51
 
        buf_block_t*    block;
52
 
 
53
 
        block = buf_page_get(space, zip_size, page_no, mode, mtr);
54
 
 
55
 
        if (mode != RW_NO_LATCH) {
56
 
 
57
 
                buf_block_dbg_add_level(block, SYNC_TREE_NODE);
58
 
        }
59
 
 
60
 
        return(block);
61
 
}
62
 
 
63
 
/**************************************************************//**
64
 
Gets a buffer page and declares its latching order level. */
65
 
UNIV_INLINE
66
 
page_t*
67
 
btr_page_get(
68
 
/*=========*/
69
 
        ulint   space,          /*!< in: space id */
70
 
        ulint   zip_size,       /*!< in: compressed page size in bytes
71
 
                                or 0 for uncompressed pages */
72
 
        ulint   page_no,        /*!< in: page number */
73
 
        ulint   mode,           /*!< in: latch mode */
74
 
        mtr_t*  mtr)            /*!< in: mtr */
75
 
{
76
 
        return(buf_block_get_frame(btr_block_get(space, zip_size, page_no,
77
 
                                                 mode, mtr)));
78
 
}
79
 
 
80
 
/**************************************************************//**
81
 
Sets the index id field of a page. */
82
 
UNIV_INLINE
83
 
void
84
 
btr_page_set_index_id(
85
 
/*==================*/
86
 
        page_t*         page,   /*!< in: page to be created */
87
 
        page_zip_des_t* page_zip,/*!< in: compressed page whose uncompressed
88
 
                                part will be updated, or NULL */
89
 
        dulint          id,     /*!< in: index id */
90
 
        mtr_t*          mtr)    /*!< in: mtr */
91
 
{
92
 
        if (UNIV_LIKELY_NULL(page_zip)) {
93
 
                mach_write_to_8(page + (PAGE_HEADER + PAGE_INDEX_ID), id);
94
 
                page_zip_write_header(page_zip,
95
 
                                      page + (PAGE_HEADER + PAGE_INDEX_ID),
96
 
                                      8, mtr);
97
 
        } else {
98
 
                mlog_write_dulint(page + (PAGE_HEADER + PAGE_INDEX_ID),
99
 
                                  id, mtr);
100
 
        }
101
 
}
102
 
#endif /* !UNIV_HOTBACKUP */
103
 
 
104
 
/**************************************************************//**
105
 
Gets the index id field of a page.
106
 
@return index id */
107
 
UNIV_INLINE
108
 
dulint
109
 
btr_page_get_index_id(
110
 
/*==================*/
111
 
        const page_t*   page)   /*!< in: index page */
112
 
{
113
 
        return(mach_read_from_8(page + PAGE_HEADER + PAGE_INDEX_ID));
114
 
}
115
 
 
116
 
#ifndef UNIV_HOTBACKUP
117
 
/********************************************************//**
118
 
Gets the node level field in an index page.
119
 
@return level, leaf level == 0 */
120
 
UNIV_INLINE
121
 
ulint
122
 
btr_page_get_level_low(
123
 
/*===================*/
124
 
        const page_t*   page)   /*!< in: index page */
125
 
{
126
 
        ulint   level;
127
 
 
128
 
        ut_ad(page);
129
 
 
130
 
        level = mach_read_from_2(page + PAGE_HEADER + PAGE_LEVEL);
131
 
 
132
 
        ut_ad(level <= BTR_MAX_NODE_LEVEL);
133
 
 
134
 
        return(level);
135
 
}
136
 
 
137
 
/********************************************************//**
138
 
Gets the node level field in an index page.
139
 
@return level, leaf level == 0 */
140
 
UNIV_INLINE
141
 
ulint
142
 
btr_page_get_level(
143
 
/*===============*/
144
 
        const page_t*   page,   /*!< in: index page */
145
 
        mtr_t*          mtr __attribute__((unused)))
146
 
                                /*!< in: mini-transaction handle */
147
 
{
148
 
        (void)mtr;
149
 
        ut_ad(page && mtr);
150
 
 
151
 
        return(btr_page_get_level_low(page));
152
 
}
153
 
 
154
 
/********************************************************//**
155
 
Sets the node level field in an index page. */
156
 
UNIV_INLINE
157
 
void
158
 
btr_page_set_level(
159
 
/*===============*/
160
 
        page_t*         page,   /*!< in: index page */
161
 
        page_zip_des_t* page_zip,/*!< in: compressed page whose uncompressed
162
 
                                part will be updated, or NULL */
163
 
        ulint           level,  /*!< in: level, leaf level == 0 */
164
 
        mtr_t*          mtr)    /*!< in: mini-transaction handle */
165
 
{
166
 
        ut_ad(page && mtr);
167
 
        ut_ad(level <= BTR_MAX_NODE_LEVEL);
168
 
 
169
 
        if (UNIV_LIKELY_NULL(page_zip)) {
170
 
                mach_write_to_2(page + (PAGE_HEADER + PAGE_LEVEL), level);
171
 
                page_zip_write_header(page_zip,
172
 
                                      page + (PAGE_HEADER + PAGE_LEVEL),
173
 
                                      2, mtr);
174
 
        } else {
175
 
                mlog_write_ulint(page + (PAGE_HEADER + PAGE_LEVEL), level,
176
 
                                 MLOG_2BYTES, mtr);
177
 
        }
178
 
}
179
 
 
180
 
/********************************************************//**
181
 
Gets the next index page number.
182
 
@return next page number */
183
 
UNIV_INLINE
184
 
ulint
185
 
btr_page_get_next(
186
 
/*==============*/
187
 
        const page_t*   page,   /*!< in: index page */
188
 
        mtr_t*          mtr __attribute__((unused)))
189
 
                                /*!< in: mini-transaction handle */
190
 
{
191
 
        (void)mtr;
192
 
        ut_ad(page && mtr);
193
 
        ut_ad(mtr_memo_contains_page(mtr, page, MTR_MEMO_PAGE_X_FIX)
194
 
              || mtr_memo_contains_page(mtr, page, MTR_MEMO_PAGE_S_FIX));
195
 
 
196
 
        return(mach_read_from_4(page + FIL_PAGE_NEXT));
197
 
}
198
 
 
199
 
/********************************************************//**
200
 
Sets the next index page field. */
201
 
UNIV_INLINE
202
 
void
203
 
btr_page_set_next(
204
 
/*==============*/
205
 
        page_t*         page,   /*!< in: index page */
206
 
        page_zip_des_t* page_zip,/*!< in: compressed page whose uncompressed
207
 
                                part will be updated, or NULL */
208
 
        ulint           next,   /*!< in: next page number */
209
 
        mtr_t*          mtr)    /*!< in: mini-transaction handle */
210
 
{
211
 
        ut_ad(page && mtr);
212
 
 
213
 
        if (UNIV_LIKELY_NULL(page_zip)) {
214
 
                mach_write_to_4(page + FIL_PAGE_NEXT, next);
215
 
                page_zip_write_header(page_zip, page + FIL_PAGE_NEXT, 4, mtr);
216
 
        } else {
217
 
                mlog_write_ulint(page + FIL_PAGE_NEXT, next, MLOG_4BYTES, mtr);
218
 
        }
219
 
}
220
 
 
221
 
/********************************************************//**
222
 
Gets the previous index page number.
223
 
@return prev page number */
224
 
UNIV_INLINE
225
 
ulint
226
 
btr_page_get_prev(
227
 
/*==============*/
228
 
        const page_t*   page,   /*!< in: index page */
229
 
        mtr_t*  mtr __attribute__((unused))) /*!< in: mini-transaction handle */
230
 
{
231
 
        (void)mtr;
232
 
        ut_ad(page && mtr);
233
 
 
234
 
        return(mach_read_from_4(page + FIL_PAGE_PREV));
235
 
}
236
 
 
237
 
/********************************************************//**
238
 
Sets the previous index page field. */
239
 
UNIV_INLINE
240
 
void
241
 
btr_page_set_prev(
242
 
/*==============*/
243
 
        page_t*         page,   /*!< in: index page */
244
 
        page_zip_des_t* page_zip,/*!< in: compressed page whose uncompressed
245
 
                                part will be updated, or NULL */
246
 
        ulint           prev,   /*!< in: previous page number */
247
 
        mtr_t*          mtr)    /*!< in: mini-transaction handle */
248
 
{
249
 
        ut_ad(page && mtr);
250
 
 
251
 
        if (UNIV_LIKELY_NULL(page_zip)) {
252
 
                mach_write_to_4(page + FIL_PAGE_PREV, prev);
253
 
                page_zip_write_header(page_zip, page + FIL_PAGE_PREV, 4, mtr);
254
 
        } else {
255
 
                mlog_write_ulint(page + FIL_PAGE_PREV, prev, MLOG_4BYTES, mtr);
256
 
        }
257
 
}
258
 
 
259
 
/**************************************************************//**
260
 
Gets the child node file address in a node pointer.
261
 
@return child node address */
262
 
UNIV_INLINE
263
 
ulint
264
 
btr_node_ptr_get_child_page_no(
265
 
/*===========================*/
266
 
        const rec_t*    rec,    /*!< in: node pointer record */
267
 
        const ulint*    offsets)/*!< in: array returned by rec_get_offsets() */
268
 
{
269
 
        const byte*     field;
270
 
        ulint           len;
271
 
        ulint           page_no;
272
 
 
273
 
        ut_ad(!rec_offs_comp(offsets) || rec_get_node_ptr_flag(rec));
274
 
 
275
 
        /* The child address is in the last field */
276
 
        field = rec_get_nth_field(rec, offsets,
277
 
                                  rec_offs_n_fields(offsets) - 1, &len);
278
 
 
279
 
        ut_ad(len == 4);
280
 
 
281
 
        page_no = mach_read_from_4(field);
282
 
 
283
 
        if (UNIV_UNLIKELY(page_no == 0)) {
284
 
                fprintf(stderr,
285
 
                        "InnoDB: a nonsensical page number 0"
286
 
                        " in a node ptr record at offset %lu\n",
287
 
                        (ulong) page_offset(rec));
288
 
                buf_page_print(page_align(rec), 0);
289
 
        }
290
 
 
291
 
        return(page_no);
292
 
}
293
 
 
294
 
/**************************************************************//**
295
 
Releases the latches on a leaf page and bufferunfixes it. */
296
 
UNIV_INLINE
297
 
void
298
 
btr_leaf_page_release(
299
 
/*==================*/
300
 
        buf_block_t*    block,          /*!< in: buffer block */
301
 
        ulint           latch_mode,     /*!< in: BTR_SEARCH_LEAF or
302
 
                                        BTR_MODIFY_LEAF */
303
 
        mtr_t*          mtr)            /*!< in: mtr */
304
 
{
305
 
        ut_ad(latch_mode == BTR_SEARCH_LEAF || latch_mode == BTR_MODIFY_LEAF);
306
 
        ut_ad(!mtr_memo_contains(mtr, block, MTR_MEMO_MODIFY));
307
 
 
308
 
        mtr_memo_release(mtr, block,
309
 
                         latch_mode == BTR_SEARCH_LEAF
310
 
                         ? MTR_MEMO_PAGE_S_FIX
311
 
                         : MTR_MEMO_PAGE_X_FIX);
312
 
}
313
 
#endif /* !UNIV_HOTBACKUP */