← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

Imported InnoDB plugin with changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/page0cur.ic
7
7
*************************************************************************/
8
8
 
9
9
#include "page0page.h"
10
 
 
11
 
 
 
10
#include "buf0types.h"
 
11
 
 
12
#ifdef UNIV_DEBUG
12
13
/*************************************************************
13
14
Gets pointer to the page frame where the cursor is positioned. */
14
15
UNIV_INLINE
19
20
        page_cur_t*     cur)    /* in: page cursor */
20
21
{
21
22
        ut_ad(cur);
22
 
 
23
 
        return(buf_frame_align(cur->rec));
 
23
        ut_ad(page_align(cur->rec) == cur->block->frame);
 
24
 
 
25
        return(page_align(cur->rec));
 
26
}
 
27
 
 
28
/*************************************************************
 
29
Gets pointer to the buffer block where the cursor is positioned. */
 
30
UNIV_INLINE
 
31
buf_block_t*
 
32
page_cur_get_block(
 
33
/*===============*/
 
34
                                /* out: page */
 
35
        page_cur_t*     cur)    /* in: page cursor */
 
36
{
 
37
        ut_ad(cur);
 
38
        ut_ad(page_align(cur->rec) == cur->block->frame);
 
39
        return(cur->block);
 
40
}
 
41
 
 
42
/*************************************************************
 
43
Gets pointer to the page frame where the cursor is positioned. */
 
44
UNIV_INLINE
 
45
page_zip_des_t*
 
46
page_cur_get_page_zip(
 
47
/*==================*/
 
48
                                /* out: page */
 
49
        page_cur_t*     cur)    /* in: page cursor */
 
50
{
 
51
        return(buf_block_get_page_zip(page_cur_get_block(cur)));
24
52
}
25
53
 
26
54
/*************************************************************
33
61
        page_cur_t*     cur)    /* in: page cursor */
34
62
{
35
63
        ut_ad(cur);
 
64
        ut_ad(page_align(cur->rec) == cur->block->frame);
36
65
 
37
66
        return(cur->rec);
38
67
}
 
68
#endif /* UNIV_DEBUG */
39
69
 
40
70
/*************************************************************
41
71
Sets the cursor object to point before the first user record
44
74
void
45
75
page_cur_set_before_first(
46
76
/*======================*/
47
 
        page_t*         page,   /* in: index page */
48
 
        page_cur_t*     cur)    /* in: cursor */
 
77
        const buf_block_t*      block,  /* in: index page */
 
78
        page_cur_t*             cur)    /* in: cursor */
49
79
{
50
 
        cur->rec = page_get_infimum_rec(page);
 
80
        cur->block = (buf_block_t*) block;
 
81
        cur->rec = page_get_infimum_rec(buf_block_get_frame(cur->block));
51
82
}
52
83
 
53
84
/*************************************************************
57
88
void
58
89
page_cur_set_after_last(
59
90
/*====================*/
60
 
        page_t*         page,   /* in: index page */
61
 
        page_cur_t*     cur)    /* in: cursor */
 
91
        const buf_block_t*      block,  /* in: index page */
 
92
        page_cur_t*             cur)    /* in: cursor */
62
93
{
63
 
        cur->rec = page_get_supremum_rec(page);
 
94
        cur->block = (buf_block_t*) block;
 
95
        cur->rec = page_get_supremum_rec(buf_block_get_frame(cur->block));
64
96
}
65
97
 
66
98
/*************************************************************
72
104
                                        /* out: TRUE if at start */
73
105
        const page_cur_t*       cur)    /* in: cursor */
74
106
{
 
107
        ut_ad(cur);
 
108
        ut_ad(page_align(cur->rec) == cur->block->frame);
75
109
        return(page_rec_is_infimum(cur->rec));
76
110
}
77
111
 
84
118
                                        /* out: TRUE if at end */
85
119
        const page_cur_t*       cur)    /* in: cursor */
86
120
{
 
121
        ut_ad(cur);
 
122
        ut_ad(page_align(cur->rec) == cur->block->frame);
87
123
        return(page_rec_is_supremum(cur->rec));
88
124
}
89
125
 
93
129
void
94
130
page_cur_position(
95
131
/*==============*/
96
 
        rec_t*          rec,    /* in: record on a page */
97
 
        page_cur_t*     cur)    /* in: page cursor */
 
132
        const rec_t*            rec,    /* in: record on a page */
 
133
        const buf_block_t*      block,  /* in: buffer block containing
 
134
                                        the record */
 
135
        page_cur_t*             cur)    /* out: page cursor */
98
136
{
99
 
        ut_ad(rec && cur);
 
137
        ut_ad(rec && block && cur);
 
138
        ut_ad(page_align(rec) == block->frame);
100
139
 
101
 
        cur->rec = rec;
 
140
        cur->rec = (rec_t*) rec;
 
141
        cur->block = (buf_block_t*) block;
102
142
}
103
143
 
104
144
/**************************************************************
107
147
void
108
148
page_cur_invalidate(
109
149
/*================*/
110
 
        page_cur_t*     cur)    /* in: page cursor */
 
150
        page_cur_t*     cur)    /* out: page cursor */
111
151
{
112
152
        ut_ad(cur);
113
153
 
114
154
        cur->rec = NULL;
 
155
        cur->block = NULL;
115
156
}
116
157
 
117
158
/**************************************************************
120
161
void
121
162
page_cur_move_to_next(
122
163
/*==================*/
123
 
        page_cur_t*     cur)    /* in: cursor; must not be after last */
 
164
        page_cur_t*     cur)    /* in/out: cursor; must not be after last */
124
165
{
125
166
        ut_ad(!page_cur_is_after_last(cur));
126
167
 
133
174
void
134
175
page_cur_move_to_prev(
135
176
/*==================*/
136
 
        page_cur_t*     cur)    /* in: page cursor, not before first */
 
177
        page_cur_t*     cur)    /* in/out: page cursor, not before first */
137
178
{
138
179
        ut_ad(!page_cur_is_before_first(cur));
139
180
 
146
187
ulint
147
188
page_cur_search(
148
189
/*============*/
149
 
                                /* out: number of matched fields on the left */
150
 
        page_t*         page,   /* in: index page */
151
 
        dict_index_t*   index,  /* in: record descriptor */
152
 
        dtuple_t*       tuple,  /* in: data tuple */
153
 
        ulint           mode,   /* in: PAGE_CUR_L, PAGE_CUR_LE, PAGE_CUR_G,
154
 
                                or PAGE_CUR_GE */
155
 
        page_cur_t*     cursor) /* out: page cursor */
 
190
                                        /* out: number of matched
 
191
                                        fields on the left */
 
192
        const buf_block_t*      block,  /* in: buffer block */
 
193
        const dict_index_t*     index,  /* in: record descriptor */
 
194
        const dtuple_t*         tuple,  /* in: data tuple */
 
195
        ulint                   mode,   /* in: PAGE_CUR_L,
 
196
                                        PAGE_CUR_LE, PAGE_CUR_G, or
 
197
                                        PAGE_CUR_GE */
 
198
        page_cur_t*             cursor) /* out: page cursor */
156
199
{
157
200
        ulint           low_matched_fields = 0;
158
201
        ulint           low_matched_bytes = 0;
161
204
 
162
205
        ut_ad(dtuple_check_typed(tuple));
163
206
 
164
 
        page_cur_search_with_match(page, index, tuple, mode,
 
207
        page_cur_search_with_match(block, index, tuple, mode,
165
208
                                   &up_matched_fields,
166
209
                                   &up_matched_bytes,
167
210
                                   &low_matched_fields,
173
216
/***************************************************************
174
217
Inserts a record next to page cursor. Returns pointer to inserted record if
175
218
succeed, i.e., enough space available, NULL otherwise. The cursor stays at
176
 
the same position. */
 
219
the same logical position, but the physical position may change if it is
 
220
pointing to a compressed page that was reorganized. */
177
221
UNIV_INLINE
178
222
rec_t*
179
223
page_cur_tuple_insert(
180
224
/*==================*/
181
225
                                /* out: pointer to record if succeed, NULL
182
226
                                otherwise */
183
 
        page_cur_t*     cursor, /* in: a page cursor */
184
 
        dtuple_t*       tuple,  /* in: pointer to a data tuple */
 
227
        page_cur_t*     cursor, /* in/out: a page cursor */
 
228
        const dtuple_t* tuple,  /* in: pointer to a data tuple */
185
229
        dict_index_t*   index,  /* in: record descriptor */
186
 
        mtr_t*          mtr)    /* in: mini-transaction handle */
 
230
        ulint           n_ext,  /* in: number of externally stored columns */
 
231
        mtr_t*          mtr)    /* in: mini-transaction handle, or NULL */
187
232
{
188
 
        return(page_cur_insert_rec_low(cursor, tuple, index, NULL, NULL, mtr));
 
233
        mem_heap_t*     heap;
 
234
        ulint*          offsets;
 
235
        ulint           size
 
236
                = rec_get_converted_size(index, tuple, n_ext);
 
237
        rec_t*          rec;
 
238
 
 
239
        heap = mem_heap_create(size
 
240
                               + (4 + REC_OFFS_HEADER_SIZE
 
241
                                  + dtuple_get_n_fields(tuple))
 
242
                               * sizeof *offsets);
 
243
        rec = rec_convert_dtuple_to_rec((byte*) mem_heap_alloc(heap, size),
 
244
                                        index, tuple, n_ext);
 
245
        offsets = rec_get_offsets(rec, index, NULL, ULINT_UNDEFINED, &heap);
 
246
 
 
247
        if (buf_block_get_page_zip(cursor->block)) {
 
248
                rec = page_cur_insert_rec_zip(&cursor->rec, cursor->block,
 
249
                                              index, rec, offsets, mtr);
 
250
        } else {
 
251
                rec = page_cur_insert_rec_low(cursor->rec,
 
252
                                              index, rec, offsets, mtr);
 
253
        }
 
254
 
 
255
        mem_heap_free(heap);
 
256
        return(rec);
189
257
}
190
258
 
191
259
/***************************************************************
192
260
Inserts a record next to page cursor. Returns pointer to inserted record if
193
261
succeed, i.e., enough space available, NULL otherwise. The cursor stays at
194
 
the same position. */
 
262
the same logical position, but the physical position may change if it is
 
263
pointing to a compressed page that was reorganized. */
195
264
UNIV_INLINE
196
265
rec_t*
197
266
page_cur_rec_insert(
198
267
/*================*/
199
268
                                /* out: pointer to record if succeed, NULL
200
269
                                otherwise */
201
 
        page_cur_t*     cursor, /* in: a page cursor */
202
 
        rec_t*          rec,    /* in: record to insert */
 
270
        page_cur_t*     cursor, /* in/out: a page cursor */
 
271
        const rec_t*    rec,    /* in: record to insert */
203
272
        dict_index_t*   index,  /* in: record descriptor */
204
 
        ulint*          offsets,/* in: rec_get_offsets(rec, index) */
205
 
        mtr_t*          mtr)    /* in: mini-transaction handle */
 
273
        ulint*          offsets,/* in/out: rec_get_offsets(rec, index) */
 
274
        mtr_t*          mtr)    /* in: mini-transaction handle, or NULL */
206
275
{
207
 
        return(page_cur_insert_rec_low(cursor, NULL, index, rec,
208
 
                                       offsets, mtr));
 
276
        if (buf_block_get_page_zip(cursor->block)) {
 
277
                return(page_cur_insert_rec_zip(&cursor->rec, cursor->block,
 
278
                                               index, rec, offsets, mtr));
 
279
        } else {
 
280
                return(page_cur_insert_rec_low(cursor->rec,
 
281
                                               index, rec, offsets, mtr));
 
282
        }
209
283
}
210
284