← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2008-10-28 08:36:02 UTC
  • mfrom: (520.4.13 merge-innodb-plugin)
  • Revision ID: brian@tangent.org-20081028083602-0p3zzlhlxr5q2sqo
Merging Monty's work

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/btr0btr.ic
9
9
#include "mach0data.h"
10
10
#include "mtr0mtr.h"
11
11
#include "mtr0log.h"
 
12
#include "page0zip.h"
12
13
 
13
14
#define BTR_MAX_NODE_LEVEL      50      /* used in debug checking */
14
15
 
15
16
/******************************************************************
16
17
Gets a buffer page and declares its latching order level. */
17
18
UNIV_INLINE
 
19
buf_block_t*
 
20
btr_block_get(
 
21
/*==========*/
 
22
        ulint   space,          /* in: space id */
 
23
        ulint   zip_size,       /* in: compressed page size in bytes
 
24
                                or 0 for uncompressed pages */
 
25
        ulint   page_no,        /* in: page number */
 
26
        ulint   mode,           /* in: latch mode */
 
27
        mtr_t*  mtr)            /* in: mtr */
 
28
{
 
29
        buf_block_t*    block;
 
30
 
 
31
        block = buf_page_get(space, zip_size, page_no, mode, mtr);
 
32
#ifdef UNIV_SYNC_DEBUG
 
33
        if (mode != RW_NO_LATCH) {
 
34
 
 
35
                buf_block_dbg_add_level(block, SYNC_TREE_NODE);
 
36
        }
 
37
#endif
 
38
        return(block);
 
39
}
 
40
 
 
41
/******************************************************************
 
42
Gets a buffer page and declares its latching order level. */
 
43
UNIV_INLINE
18
44
page_t*
19
45
btr_page_get(
20
46
/*=========*/
21
47
        ulint   space,          /* in: space id */
 
48
        ulint   zip_size,       /* in: compressed page size in bytes
 
49
                                or 0 for uncompressed pages */
22
50
        ulint   page_no,        /* in: page number */
23
51
        ulint   mode,           /* in: latch mode */
24
52
        mtr_t*  mtr)            /* in: mtr */
25
53
{
26
 
        page_t* page;
27
 
 
28
 
        page = buf_page_get(space, page_no, mode, mtr);
29
 
#ifdef UNIV_SYNC_DEBUG
30
 
        if (mode != RW_NO_LATCH) {
31
 
 
32
 
                buf_page_dbg_add_level(page, SYNC_TREE_NODE);
33
 
        }
34
 
#endif
35
 
        return(page);
 
54
        return(buf_block_get_frame(btr_block_get(space, zip_size, page_no,
 
55
                                                 mode, mtr)));
36
56
}
37
57
 
38
58
/******************************************************************
42
62
btr_page_set_index_id(
43
63
/*==================*/
44
64
        page_t*         page,   /* in: page to be created */
 
65
        page_zip_des_t* page_zip,/* in: compressed page whose uncompressed
 
66
                                part will be updated, or NULL */
45
67
        dulint          id,     /* in: index id */
46
68
        mtr_t*          mtr)    /* in: mtr */
47
69
{
48
 
        mlog_write_dulint(page + PAGE_HEADER + PAGE_INDEX_ID, id, mtr);
 
70
        if (UNIV_LIKELY_NULL(page_zip)) {
 
71
                mach_write_to_8(page + (PAGE_HEADER + PAGE_INDEX_ID), id);
 
72
                page_zip_write_header(page_zip,
 
73
                                      page + (PAGE_HEADER + PAGE_INDEX_ID),
 
74
                                      8, mtr);
 
75
        } else {
 
76
                mlog_write_dulint(page + (PAGE_HEADER + PAGE_INDEX_ID),
 
77
                                  id, mtr);
 
78
        }
49
79
}
50
80
 
51
81
/******************************************************************
55
85
btr_page_get_index_id(
56
86
/*==================*/
57
87
                                /* out: index id */
58
 
        page_t*         page)   /* in: index page */
 
88
        const page_t*   page)   /* in: index page */
59
89
{
60
90
        return(mach_read_from_8(page + PAGE_HEADER + PAGE_INDEX_ID));
61
91
}
66
96
ulint
67
97
btr_page_get_level_low(
68
98
/*===================*/
69
 
                        /* out: level, leaf level == 0 */
70
 
        page_t* page)   /* in: index page */
 
99
                                /* out: level, leaf level == 0 */
 
100
        const page_t*   page)   /* in: index page */
71
101
{
72
102
        ulint   level;
73
103
 
86
116
ulint
87
117
btr_page_get_level(
88
118
/*===============*/
89
 
                        /* out: level, leaf level == 0 */
90
 
        page_t* page,   /* in: index page */
91
 
        mtr_t*  mtr __attribute__((unused))) /* in: mini-transaction handle */
 
119
                                /* out: level, leaf level == 0 */
 
120
        const page_t*   page,   /* in: index page */
 
121
        mtr_t*          mtr __attribute__((unused)))
 
122
                                /* in: mini-transaction handle */
92
123
{
93
124
        ut_ad(page && mtr);
94
125
 
101
132
void
102
133
btr_page_set_level(
103
134
/*===============*/
104
 
        page_t* page,   /* in: index page */
105
 
        ulint   level,  /* in: level, leaf level == 0 */
106
 
        mtr_t*  mtr)    /* in: mini-transaction handle */
 
135
        page_t*         page,   /* in: index page */
 
136
        page_zip_des_t* page_zip,/* in: compressed page whose uncompressed
 
137
                                part will be updated, or NULL */
 
138
        ulint           level,  /* in: level, leaf level == 0 */
 
139
        mtr_t*          mtr)    /* in: mini-transaction handle */
107
140
{
108
141
        ut_ad(page && mtr);
109
142
        ut_ad(level <= BTR_MAX_NODE_LEVEL);
110
143
 
111
 
        mlog_write_ulint(page + PAGE_HEADER + PAGE_LEVEL, level,
112
 
                         MLOG_2BYTES, mtr);
 
144
        if (UNIV_LIKELY_NULL(page_zip)) {
 
145
                mach_write_to_2(page + (PAGE_HEADER + PAGE_LEVEL), level);
 
146
                page_zip_write_header(page_zip,
 
147
                                      page + (PAGE_HEADER + PAGE_LEVEL),
 
148
                                      2, mtr);
 
149
        } else {
 
150
                mlog_write_ulint(page + (PAGE_HEADER + PAGE_LEVEL), level,
 
151
                                 MLOG_2BYTES, mtr);
 
152
        }
113
153
}
114
154
 
115
155
/************************************************************
118
158
ulint
119
159
btr_page_get_next(
120
160
/*==============*/
121
 
                        /* out: next page number */
122
 
        page_t* page,   /* in: index page */
123
 
        mtr_t*  mtr __attribute__((unused))) /* in: mini-transaction handle */
 
161
                                /* out: next page number */
 
162
        const page_t*   page,   /* in: index page */
 
163
        mtr_t*          mtr __attribute__((unused)))
 
164
                                /* in: mini-transaction handle */
124
165
{
125
166
        ut_ad(page && mtr);
126
 
        ut_ad(mtr_memo_contains(mtr, buf_block_align(page),
127
 
                                MTR_MEMO_PAGE_X_FIX)
128
 
              || mtr_memo_contains(mtr, buf_block_align(page),
129
 
                                   MTR_MEMO_PAGE_S_FIX));
 
167
        ut_ad(mtr_memo_contains_page(mtr, page, MTR_MEMO_PAGE_X_FIX)
 
168
              || mtr_memo_contains_page(mtr, page, MTR_MEMO_PAGE_S_FIX));
130
169
 
131
170
        return(mach_read_from_4(page + FIL_PAGE_NEXT));
132
171
}
137
176
void
138
177
btr_page_set_next(
139
178
/*==============*/
140
 
        page_t* page,   /* in: index page */
141
 
        ulint   next,   /* in: next page number */
142
 
        mtr_t*  mtr)    /* in: mini-transaction handle */
 
179
        page_t*         page,   /* in: index page */
 
180
        page_zip_des_t* page_zip,/* in: compressed page whose uncompressed
 
181
                                part will be updated, or NULL */
 
182
        ulint           next,   /* in: next page number */
 
183
        mtr_t*          mtr)    /* in: mini-transaction handle */
143
184
{
144
185
        ut_ad(page && mtr);
145
186
 
146
 
        mlog_write_ulint(page + FIL_PAGE_NEXT, next, MLOG_4BYTES, mtr);
 
187
        if (UNIV_LIKELY_NULL(page_zip)) {
 
188
                mach_write_to_4(page + FIL_PAGE_NEXT, next);
 
189
                page_zip_write_header(page_zip, page + FIL_PAGE_NEXT, 4, mtr);
 
190
        } else {
 
191
                mlog_write_ulint(page + FIL_PAGE_NEXT, next, MLOG_4BYTES, mtr);
 
192
        }
147
193
}
148
194
 
149
195
/************************************************************
152
198
ulint
153
199
btr_page_get_prev(
154
200
/*==============*/
155
 
                        /* out: prev page number */
156
 
        page_t* page,   /* in: index page */
 
201
                                /* out: prev page number */
 
202
        const page_t*   page,   /* in: index page */
157
203
        mtr_t*  mtr __attribute__((unused))) /* in: mini-transaction handle */
158
204
{
159
205
        ut_ad(page && mtr);
167
213
void
168
214
btr_page_set_prev(
169
215
/*==============*/
170
 
        page_t* page,   /* in: index page */
171
 
        ulint   prev,   /* in: previous page number */
172
 
        mtr_t*  mtr)    /* in: mini-transaction handle */
 
216
        page_t*         page,   /* in: index page */
 
217
        page_zip_des_t* page_zip,/* in: compressed page whose uncompressed
 
218
                                part will be updated, or NULL */
 
219
        ulint           prev,   /* in: previous page number */
 
220
        mtr_t*          mtr)    /* in: mini-transaction handle */
173
221
{
174
222
        ut_ad(page && mtr);
175
223
 
176
 
        mlog_write_ulint(page + FIL_PAGE_PREV, prev, MLOG_4BYTES, mtr);
 
224
        if (UNIV_LIKELY_NULL(page_zip)) {
 
225
                mach_write_to_4(page + FIL_PAGE_PREV, prev);
 
226
                page_zip_write_header(page_zip, page + FIL_PAGE_PREV, 4, mtr);
 
227
        } else {
 
228
                mlog_write_ulint(page + FIL_PAGE_PREV, prev, MLOG_4BYTES, mtr);
 
229
        }
177
230
}
178
231
 
179
232
/******************************************************************
183
236
btr_node_ptr_get_child_page_no(
184
237
/*===========================*/
185
238
                                /* out: child node address */
186
 
        rec_t*          rec,    /* in: node pointer record */
 
239
        const rec_t*    rec,    /* in: node pointer record */
187
240
        const ulint*    offsets)/* in: array returned by rec_get_offsets() */
188
241
{
189
 
        byte*   field;
190
 
        ulint   len;
191
 
        ulint   page_no;
 
242
        const byte*     field;
 
243
        ulint           len;
 
244
        ulint           page_no;
192
245
 
193
246
        ut_ad(!rec_offs_comp(offsets) || rec_get_node_ptr_flag(rec));
194
247
 
205
258
                        "InnoDB: a nonsensical page number 0"
206
259
                        " in a node ptr record at offset %lu\n",
207
260
                        (ulong) page_offset(rec));
208
 
                buf_page_print(buf_frame_align(rec));
 
261
                buf_page_print(page_align(rec), 0);
209
262
        }
210
263
 
211
264
        return(page_no);
217
270
void
218
271
btr_leaf_page_release(
219
272
/*==================*/
220
 
        page_t* page,           /* in: page */
221
 
        ulint   latch_mode,     /* in: BTR_SEARCH_LEAF or BTR_MODIFY_LEAF */
222
 
        mtr_t*  mtr)            /* in: mtr */
 
273
        buf_block_t*    block,          /* in: buffer block */
 
274
        ulint           latch_mode,     /* in: BTR_SEARCH_LEAF or
 
275
                                        BTR_MODIFY_LEAF */
 
276
        mtr_t*          mtr)            /* in: mtr */
223
277
{
224
 
        ut_ad(!mtr_memo_contains(mtr, buf_block_align(page),
225
 
                                 MTR_MEMO_MODIFY));
226
 
        if (latch_mode == BTR_SEARCH_LEAF) {
227
 
                mtr_memo_release(mtr, buf_block_align(page),
228
 
                                 MTR_MEMO_PAGE_S_FIX);
229
 
        } else {
230
 
                ut_ad(latch_mode == BTR_MODIFY_LEAF);
231
 
                mtr_memo_release(mtr, buf_block_align(page),
232
 
                                 MTR_MEMO_PAGE_X_FIX);
233
 
        }
 
278
        ut_ad(latch_mode == BTR_SEARCH_LEAF || latch_mode == BTR_MODIFY_LEAF);
 
279
        ut_ad(!mtr_memo_contains(mtr, block, MTR_MEMO_MODIFY));
 
280
 
 
281
        mtr_memo_release(mtr, block,
 
282
                         latch_mode == BTR_SEARCH_LEAF
 
283
                         ? MTR_MEMO_PAGE_S_FIX
 
284
                         : MTR_MEMO_PAGE_X_FIX);
234
285
}