← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Monty Taylor
  • Date: 2008-09-15 17:24:04 UTC
  • Revision ID: monty@inaugust.com-20080915172404-ygh6hiyu0q7qpa9x
Removed strndup calls.

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