← 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/btr0pcur.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/btr0pcur.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/btr0pcur.ic
 
21
The index tree persistent cursor
 
22
 
 
23
Created 2/23/1996 Heikki Tuuri
 
24
*******************************************************/
 
25
 
 
26
 
 
27
/*********************************************************//**
 
28
Gets the rel_pos field for a cursor whose position has been stored.
 
29
@return BTR_PCUR_ON, ... */
 
30
UNIV_INLINE
 
31
ulint
 
32
btr_pcur_get_rel_pos(
 
33
/*=================*/
 
34
        const btr_pcur_t*       cursor) /*!< in: persistent cursor */
 
35
{
 
36
        ut_ad(cursor);
 
37
        ut_ad(cursor->old_rec);
 
38
        ut_ad(cursor->old_stored == BTR_PCUR_OLD_STORED);
 
39
        ut_ad(cursor->pos_state == BTR_PCUR_WAS_POSITIONED
 
40
              || cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
41
 
 
42
        return(cursor->rel_pos);
 
43
}
 
44
 
 
45
/*********************************************************//**
 
46
Sets the mtr field for a pcur. */
 
47
UNIV_INLINE
 
48
void
 
49
btr_pcur_set_mtr(
 
50
/*=============*/
 
51
        btr_pcur_t*     cursor, /*!< in: persistent cursor */
 
52
        mtr_t*          mtr)    /*!< in, own: mtr */
 
53
{
 
54
        ut_ad(cursor);
 
55
 
 
56
        cursor->mtr = mtr;
 
57
}
 
58
 
 
59
/*********************************************************//**
 
60
Gets the mtr field for a pcur.
 
61
@return mtr */
 
62
UNIV_INLINE
 
63
mtr_t*
 
64
btr_pcur_get_mtr(
 
65
/*=============*/
 
66
        btr_pcur_t*     cursor) /*!< in: persistent cursor */
 
67
{
 
68
        ut_ad(cursor);
 
69
 
 
70
        return(cursor->mtr);
 
71
}
 
72
 
 
73
#ifdef UNIV_DEBUG
 
74
/*********************************************************//**
 
75
Returns the btr cursor component of a persistent cursor.
 
76
@return pointer to btr cursor component */
 
77
UNIV_INLINE
 
78
btr_cur_t*
 
79
btr_pcur_get_btr_cur(
 
80
/*=================*/
 
81
        const btr_pcur_t*       cursor) /*!< in: persistent cursor */
 
82
{
 
83
        const btr_cur_t*        btr_cur = &cursor->btr_cur;
 
84
        return((btr_cur_t*) btr_cur);
 
85
}
 
86
 
 
87
/*********************************************************//**
 
88
Returns the page cursor component of a persistent cursor.
 
89
@return pointer to page cursor component */
 
90
UNIV_INLINE
 
91
page_cur_t*
 
92
btr_pcur_get_page_cur(
 
93
/*==================*/
 
94
        const btr_pcur_t*       cursor) /*!< in: persistent cursor */
 
95
{
 
96
        return(btr_cur_get_page_cur(btr_pcur_get_btr_cur(cursor)));
 
97
}
 
98
#endif /* UNIV_DEBUG */
 
99
/*********************************************************//**
 
100
Returns the page of a persistent cursor.
 
101
@return pointer to the page */
 
102
UNIV_INLINE
 
103
page_t*
 
104
btr_pcur_get_page(
 
105
/*==============*/
 
106
        btr_pcur_t*     cursor) /*!< in: persistent cursor */
 
107
{
 
108
        ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
109
 
 
110
        return(btr_cur_get_page(btr_pcur_get_btr_cur(cursor)));
 
111
}
 
112
 
 
113
/*********************************************************//**
 
114
Returns the buffer block of a persistent cursor.
 
115
@return pointer to the block */
 
116
UNIV_INLINE
 
117
buf_block_t*
 
118
btr_pcur_get_block(
 
119
/*===============*/
 
120
        btr_pcur_t*     cursor) /*!< in: persistent cursor */
 
121
{
 
122
        ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
123
 
 
124
        return(btr_cur_get_block(btr_pcur_get_btr_cur(cursor)));
 
125
}
 
126
 
 
127
/*********************************************************//**
 
128
Returns the record of a persistent cursor.
 
129
@return pointer to the record */
 
130
UNIV_INLINE
 
131
rec_t*
 
132
btr_pcur_get_rec(
 
133
/*=============*/
 
134
        btr_pcur_t*     cursor) /*!< in: persistent cursor */
 
135
{
 
136
        ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
137
        ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
138
 
 
139
        return(btr_cur_get_rec(btr_pcur_get_btr_cur(cursor)));
 
140
}
 
141
 
 
142
/**************************************************************//**
 
143
Gets the up_match value for a pcur after a search.
 
144
@return number of matched fields at the cursor or to the right if
 
145
search mode was PAGE_CUR_GE, otherwise undefined */
 
146
UNIV_INLINE
 
147
ulint
 
148
btr_pcur_get_up_match(
 
149
/*==================*/
 
150
        btr_pcur_t*     cursor) /*!< in: memory buffer for persistent cursor */
 
151
{
 
152
        btr_cur_t*      btr_cursor;
 
153
 
 
154
        ut_ad((cursor->pos_state == BTR_PCUR_WAS_POSITIONED)
 
155
              || (cursor->pos_state == BTR_PCUR_IS_POSITIONED));
 
156
 
 
157
        btr_cursor = btr_pcur_get_btr_cur(cursor);
 
158
 
 
159
        ut_ad(btr_cursor->up_match != ULINT_UNDEFINED);
 
160
 
 
161
        return(btr_cursor->up_match);
 
162
}
 
163
 
 
164
/**************************************************************//**
 
165
Gets the low_match value for a pcur after a search.
 
166
@return number of matched fields at the cursor or to the right if
 
167
search mode was PAGE_CUR_LE, otherwise undefined */
 
168
UNIV_INLINE
 
169
ulint
 
170
btr_pcur_get_low_match(
 
171
/*===================*/
 
172
        btr_pcur_t*     cursor) /*!< in: memory buffer for persistent cursor */
 
173
{
 
174
        btr_cur_t*      btr_cursor;
 
175
 
 
176
        ut_ad((cursor->pos_state == BTR_PCUR_WAS_POSITIONED)
 
177
              || (cursor->pos_state == BTR_PCUR_IS_POSITIONED));
 
178
 
 
179
        btr_cursor = btr_pcur_get_btr_cur(cursor);
 
180
        ut_ad(btr_cursor->low_match != ULINT_UNDEFINED);
 
181
 
 
182
        return(btr_cursor->low_match);
 
183
}
 
184
 
 
185
/*********************************************************//**
 
186
Checks if the persistent cursor is after the last user record on
 
187
a page. */
 
188
UNIV_INLINE
 
189
ibool
 
190
btr_pcur_is_after_last_on_page(
 
191
/*===========================*/
 
192
        const btr_pcur_t*       cursor) /*!< in: persistent cursor */
 
193
{
 
194
        ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
195
        ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
196
 
 
197
        return(page_cur_is_after_last(btr_pcur_get_page_cur(cursor)));
 
198
}
 
199
 
 
200
/*********************************************************//**
 
201
Checks if the persistent cursor is before the first user record on
 
202
a page. */
 
203
UNIV_INLINE
 
204
ibool
 
205
btr_pcur_is_before_first_on_page(
 
206
/*=============================*/
 
207
        const btr_pcur_t*       cursor) /*!< in: persistent cursor */
 
208
{
 
209
        ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
210
        ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
211
 
 
212
        return(page_cur_is_before_first(btr_pcur_get_page_cur(cursor)));
 
213
}
 
214
 
 
215
/*********************************************************//**
 
216
Checks if the persistent cursor is on a user record. */
 
217
UNIV_INLINE
 
218
ibool
 
219
btr_pcur_is_on_user_rec(
 
220
/*====================*/
 
221
        const btr_pcur_t*       cursor) /*!< in: persistent cursor */
 
222
{
 
223
        ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
224
        ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
225
 
 
226
        if (btr_pcur_is_before_first_on_page(cursor)
 
227
            || btr_pcur_is_after_last_on_page(cursor)) {
 
228
 
 
229
                return(FALSE);
 
230
        }
 
231
 
 
232
        return(TRUE);
 
233
}
 
234
 
 
235
/*********************************************************//**
 
236
Checks if the persistent cursor is before the first user record in
 
237
the index tree. */
 
238
UNIV_INLINE
 
239
ibool
 
240
btr_pcur_is_before_first_in_tree(
 
241
/*=============================*/
 
242
        btr_pcur_t*     cursor, /*!< in: persistent cursor */
 
243
        mtr_t*          mtr)    /*!< in: mtr */
 
244
{
 
245
        ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
246
        ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
247
 
 
248
        if (btr_page_get_prev(btr_pcur_get_page(cursor), mtr) != FIL_NULL) {
 
249
 
 
250
                return(FALSE);
 
251
        }
 
252
 
 
253
        return(page_cur_is_before_first(btr_pcur_get_page_cur(cursor)));
 
254
}
 
255
 
 
256
/*********************************************************//**
 
257
Checks if the persistent cursor is after the last user record in
 
258
the index tree. */
 
259
UNIV_INLINE
 
260
ibool
 
261
btr_pcur_is_after_last_in_tree(
 
262
/*===========================*/
 
263
        btr_pcur_t*     cursor, /*!< in: persistent cursor */
 
264
        mtr_t*          mtr)    /*!< in: mtr */
 
265
{
 
266
        ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
267
        ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
268
 
 
269
        if (btr_page_get_next(btr_pcur_get_page(cursor), mtr) != FIL_NULL) {
 
270
 
 
271
                return(FALSE);
 
272
        }
 
273
 
 
274
        return(page_cur_is_after_last(btr_pcur_get_page_cur(cursor)));
 
275
}
 
276
 
 
277
/*********************************************************//**
 
278
Moves the persistent cursor to the next record on the same page. */
 
279
UNIV_INLINE
 
280
void
 
281
btr_pcur_move_to_next_on_page(
 
282
/*==========================*/
 
283
        btr_pcur_t*     cursor) /*!< in/out: persistent cursor */
 
284
{
 
285
        ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
286
        ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
287
 
 
288
        page_cur_move_to_next(btr_pcur_get_page_cur(cursor));
 
289
 
 
290
        cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
 
291
}
 
292
 
 
293
/*********************************************************//**
 
294
Moves the persistent cursor to the previous record on the same page. */
 
295
UNIV_INLINE
 
296
void
 
297
btr_pcur_move_to_prev_on_page(
 
298
/*==========================*/
 
299
        btr_pcur_t*     cursor) /*!< in/out: persistent cursor */
 
300
{
 
301
        ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
302
        ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
303
 
 
304
        page_cur_move_to_prev(btr_pcur_get_page_cur(cursor));
 
305
 
 
306
        cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
 
307
}
 
308
 
 
309
/*********************************************************//**
 
310
Moves the persistent cursor to the last record on the same page. */
 
311
UNIV_INLINE
 
312
void
 
313
btr_pcur_move_to_last_on_page(
 
314
/*==========================*/
 
315
        btr_pcur_t*     cursor, /*!< in: persistent cursor */
 
316
        mtr_t*          mtr)    /*!< in: mtr */
 
317
{
 
318
        UT_NOT_USED(mtr);
 
319
        ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
320
 
 
321
        page_cur_set_after_last(btr_pcur_get_block(cursor),
 
322
                                btr_pcur_get_page_cur(cursor));
 
323
 
 
324
        cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
 
325
}
 
326
 
 
327
/*********************************************************//**
 
328
Moves the persistent cursor to the next user record in the tree. If no user
 
329
records are left, the cursor ends up 'after last in tree'.
 
330
@return TRUE if the cursor moved forward, ending on a user record */
 
331
UNIV_INLINE
 
332
ibool
 
333
btr_pcur_move_to_next_user_rec(
 
334
/*===========================*/
 
335
        btr_pcur_t*     cursor, /*!< in: persistent cursor; NOTE that the
 
336
                                function may release the page latch */
 
337
        mtr_t*          mtr)    /*!< in: mtr */
 
338
{
 
339
        ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
340
        ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
341
        cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
 
342
loop:
 
343
        if (btr_pcur_is_after_last_on_page(cursor)) {
 
344
 
 
345
                if (btr_pcur_is_after_last_in_tree(cursor, mtr)) {
 
346
 
 
347
                        return(FALSE);
 
348
                }
 
349
 
 
350
                btr_pcur_move_to_next_page(cursor, mtr);
 
351
        } else {
 
352
                btr_pcur_move_to_next_on_page(cursor);
 
353
        }
 
354
 
 
355
        if (btr_pcur_is_on_user_rec(cursor)) {
 
356
 
 
357
                return(TRUE);
 
358
        }
 
359
 
 
360
        goto loop;
 
361
}
 
362
 
 
363
/*********************************************************//**
 
364
Moves the persistent cursor to the next record in the tree. If no records are
 
365
left, the cursor stays 'after last in tree'.
 
366
@return TRUE if the cursor was not after last in tree */
 
367
UNIV_INLINE
 
368
ibool
 
369
btr_pcur_move_to_next(
 
370
/*==================*/
 
371
        btr_pcur_t*     cursor, /*!< in: persistent cursor; NOTE that the
 
372
                                function may release the page latch */
 
373
        mtr_t*          mtr)    /*!< in: mtr */
 
374
{
 
375
        ut_ad(cursor->pos_state == BTR_PCUR_IS_POSITIONED);
 
376
        ut_ad(cursor->latch_mode != BTR_NO_LATCHES);
 
377
 
 
378
        cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
 
379
 
 
380
        if (btr_pcur_is_after_last_on_page(cursor)) {
 
381
 
 
382
                if (btr_pcur_is_after_last_in_tree(cursor, mtr)) {
 
383
 
 
384
                        return(FALSE);
 
385
                }
 
386
 
 
387
                btr_pcur_move_to_next_page(cursor, mtr);
 
388
 
 
389
                return(TRUE);
 
390
        }
 
391
 
 
392
        btr_pcur_move_to_next_on_page(cursor);
 
393
 
 
394
        return(TRUE);
 
395
}
 
396
 
 
397
/**************************************************************//**
 
398
Commits the pcur mtr and sets the pcur latch mode to BTR_NO_LATCHES,
 
399
that is, the cursor becomes detached. If there have been modifications
 
400
to the page where pcur is positioned, this can be used instead of
 
401
btr_pcur_release_leaf. Function btr_pcur_store_position should be used
 
402
before calling this, if restoration of cursor is wanted later. */
 
403
UNIV_INLINE
 
404
void
 
405
btr_pcur_commit(
 
406
/*============*/
 
407
        btr_pcur_t*     pcur)   /*!< in: persistent cursor */
 
408
{
 
409
        ut_a(pcur->pos_state == BTR_PCUR_IS_POSITIONED);
 
410
 
 
411
        pcur->latch_mode = BTR_NO_LATCHES;
 
412
 
 
413
        mtr_commit(pcur->mtr);
 
414
 
 
415
        pcur->pos_state = BTR_PCUR_WAS_POSITIONED;
 
416
}
 
417
 
 
418
/**************************************************************//**
 
419
Differs from btr_pcur_commit in that we can specify the mtr to commit. */
 
420
UNIV_INLINE
 
421
void
 
422
btr_pcur_commit_specify_mtr(
 
423
/*========================*/
 
424
        btr_pcur_t*     pcur,   /*!< in: persistent cursor */
 
425
        mtr_t*          mtr)    /*!< in: mtr to commit */
 
426
{
 
427
        ut_a(pcur->pos_state == BTR_PCUR_IS_POSITIONED);
 
428
 
 
429
        pcur->latch_mode = BTR_NO_LATCHES;
 
430
 
 
431
        mtr_commit(mtr);
 
432
 
 
433
        pcur->pos_state = BTR_PCUR_WAS_POSITIONED;
 
434
}
 
435
 
 
436
/**************************************************************//**
 
437
Sets the pcur latch mode to BTR_NO_LATCHES. */
 
438
UNIV_INLINE
 
439
void
 
440
btr_pcur_detach(
 
441
/*============*/
 
442
        btr_pcur_t*     pcur)   /*!< in: persistent cursor */
 
443
{
 
444
        ut_a(pcur->pos_state == BTR_PCUR_IS_POSITIONED);
 
445
 
 
446
        pcur->latch_mode = BTR_NO_LATCHES;
 
447
 
 
448
        pcur->pos_state = BTR_PCUR_WAS_POSITIONED;
 
449
}
 
450
 
 
451
/**************************************************************//**
 
452
Tests if a cursor is detached: that is the latch mode is BTR_NO_LATCHES.
 
453
@return TRUE if detached */
 
454
UNIV_INLINE
 
455
ibool
 
456
btr_pcur_is_detached(
 
457
/*=================*/
 
458
        btr_pcur_t*     pcur)   /*!< in: persistent cursor */
 
459
{
 
460
        if (pcur->latch_mode == BTR_NO_LATCHES) {
 
461
 
 
462
                return(TRUE);
 
463
        }
 
464
 
 
465
        return(FALSE);
 
466
}
 
467
 
 
468
/**************************************************************//**
 
469
Sets the old_rec_buf field to NULL. */
 
470
UNIV_INLINE
 
471
void
 
472
btr_pcur_init(
 
473
/*==========*/
 
474
        btr_pcur_t*     pcur)   /*!< in: persistent cursor */
 
475
{
 
476
        pcur->old_stored = BTR_PCUR_OLD_NOT_STORED;
 
477
        pcur->old_rec_buf = NULL;
 
478
        pcur->old_rec = NULL;
 
479
}
 
480
 
 
481
/**************************************************************//**
 
482
Initializes and opens a persistent cursor to an index tree. It should be
 
483
closed with btr_pcur_close. */
 
484
UNIV_INLINE
 
485
void
 
486
btr_pcur_open(
 
487
/*==========*/
 
488
        dict_index_t*   index,  /*!< in: index */
 
489
        const dtuple_t* tuple,  /*!< in: tuple on which search done */
 
490
        ulint           mode,   /*!< in: PAGE_CUR_L, ...;
 
491
                                NOTE that if the search is made using a unique
 
492
                                prefix of a record, mode should be
 
493
                                PAGE_CUR_LE, not PAGE_CUR_GE, as the latter
 
494
                                may end up on the previous page from the
 
495
                                record! */
 
496
        ulint           latch_mode,/*!< in: BTR_SEARCH_LEAF, ... */
 
497
        btr_pcur_t*     cursor, /*!< in: memory buffer for persistent cursor */
 
498
        mtr_t*          mtr)    /*!< in: mtr */
 
499
{
 
500
        btr_cur_t*      btr_cursor;
 
501
 
 
502
        /* Initialize the cursor */
 
503
 
 
504
        btr_pcur_init(cursor);
 
505
 
 
506
        cursor->latch_mode = latch_mode;
 
507
        cursor->search_mode = mode;
 
508
 
 
509
        /* Search with the tree cursor */
 
510
 
 
511
        btr_cursor = btr_pcur_get_btr_cur(cursor);
 
512
 
 
513
        btr_cur_search_to_nth_level(index, 0, tuple, mode, latch_mode,
 
514
                                    btr_cursor, 0, mtr);
 
515
        cursor->pos_state = BTR_PCUR_IS_POSITIONED;
 
516
 
 
517
        cursor->trx_if_known = NULL;
 
518
}
 
519
 
 
520
/**************************************************************//**
 
521
Opens an persistent cursor to an index tree without initializing the
 
522
cursor. */
 
523
UNIV_INLINE
 
524
void
 
525
btr_pcur_open_with_no_init(
 
526
/*=======================*/
 
527
        dict_index_t*   index,  /*!< in: index */
 
528
        const dtuple_t* tuple,  /*!< in: tuple on which search done */
 
529
        ulint           mode,   /*!< in: PAGE_CUR_L, ...;
 
530
                                NOTE that if the search is made using a unique
 
531
                                prefix of a record, mode should be
 
532
                                PAGE_CUR_LE, not PAGE_CUR_GE, as the latter
 
533
                                may end up on the previous page of the
 
534
                                record! */
 
535
        ulint           latch_mode,/*!< in: BTR_SEARCH_LEAF, ...;
 
536
                                NOTE that if has_search_latch != 0 then
 
537
                                we maybe do not acquire a latch on the cursor
 
538
                                page, but assume that the caller uses his
 
539
                                btr search latch to protect the record! */
 
540
        btr_pcur_t*     cursor, /*!< in: memory buffer for persistent cursor */
 
541
        ulint           has_search_latch,/*!< in: latch mode the caller
 
542
                                currently has on btr_search_latch:
 
543
                                RW_S_LATCH, or 0 */
 
544
        mtr_t*          mtr)    /*!< in: mtr */
 
545
{
 
546
        btr_cur_t*      btr_cursor;
 
547
 
 
548
        cursor->latch_mode = latch_mode;
 
549
        cursor->search_mode = mode;
 
550
 
 
551
        /* Search with the tree cursor */
 
552
 
 
553
        btr_cursor = btr_pcur_get_btr_cur(cursor);
 
554
 
 
555
        btr_cur_search_to_nth_level(index, 0, tuple, mode, latch_mode,
 
556
                                    btr_cursor, has_search_latch, mtr);
 
557
        cursor->pos_state = BTR_PCUR_IS_POSITIONED;
 
558
 
 
559
        cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
 
560
 
 
561
        cursor->trx_if_known = NULL;
 
562
}
 
563
 
 
564
/*****************************************************************//**
 
565
Opens a persistent cursor at either end of an index. */
 
566
UNIV_INLINE
 
567
void
 
568
btr_pcur_open_at_index_side(
 
569
/*========================*/
 
570
        ibool           from_left,      /*!< in: TRUE if open to the low end,
 
571
                                        FALSE if to the high end */
 
572
        dict_index_t*   index,          /*!< in: index */
 
573
        ulint           latch_mode,     /*!< in: latch mode */
 
574
        btr_pcur_t*     pcur,           /*!< in: cursor */
 
575
        ibool           do_init,        /*!< in: TRUE if should be initialized */
 
576
        mtr_t*          mtr)            /*!< in: mtr */
 
577
{
 
578
        pcur->latch_mode = latch_mode;
 
579
 
 
580
        if (from_left) {
 
581
                pcur->search_mode = PAGE_CUR_G;
 
582
        } else {
 
583
                pcur->search_mode = PAGE_CUR_L;
 
584
        }
 
585
 
 
586
        if (do_init) {
 
587
                btr_pcur_init(pcur);
 
588
        }
 
589
 
 
590
        btr_cur_open_at_index_side(from_left, index, latch_mode,
 
591
                                   btr_pcur_get_btr_cur(pcur), mtr);
 
592
        pcur->pos_state = BTR_PCUR_IS_POSITIONED;
 
593
 
 
594
        pcur->old_stored = BTR_PCUR_OLD_NOT_STORED;
 
595
 
 
596
        pcur->trx_if_known = NULL;
 
597
}
 
598
 
 
599
/**********************************************************************//**
 
600
Positions a cursor at a randomly chosen position within a B-tree. */
 
601
UNIV_INLINE
 
602
void
 
603
btr_pcur_open_at_rnd_pos(
 
604
/*=====================*/
 
605
        dict_index_t*   index,          /*!< in: index */
 
606
        ulint           latch_mode,     /*!< in: BTR_SEARCH_LEAF, ... */
 
607
        btr_pcur_t*     cursor,         /*!< in/out: B-tree pcur */
 
608
        mtr_t*          mtr)            /*!< in: mtr */
 
609
{
 
610
        /* Initialize the cursor */
 
611
 
 
612
        cursor->latch_mode = latch_mode;
 
613
        cursor->search_mode = PAGE_CUR_G;
 
614
 
 
615
        btr_pcur_init(cursor);
 
616
 
 
617
        btr_cur_open_at_rnd_pos(index, latch_mode,
 
618
                                btr_pcur_get_btr_cur(cursor), mtr);
 
619
        cursor->pos_state = BTR_PCUR_IS_POSITIONED;
 
620
        cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
 
621
 
 
622
        cursor->trx_if_known = NULL;
 
623
}
 
624
 
 
625
/**************************************************************//**
 
626
Frees the possible memory heap of a persistent cursor and sets the latch
 
627
mode of the persistent cursor to BTR_NO_LATCHES. */
 
628
UNIV_INLINE
 
629
void
 
630
btr_pcur_close(
 
631
/*===========*/
 
632
        btr_pcur_t*     cursor) /*!< in: persistent cursor */
 
633
{
 
634
        if (cursor->old_rec_buf != NULL) {
 
635
 
 
636
                mem_free(cursor->old_rec_buf);
 
637
 
 
638
                cursor->old_rec = NULL;
 
639
                cursor->old_rec_buf = NULL;
 
640
        }
 
641
 
 
642
        cursor->btr_cur.page_cur.rec = NULL;
 
643
        cursor->btr_cur.page_cur.block = NULL;
 
644
        cursor->old_rec = NULL;
 
645
        cursor->old_stored = BTR_PCUR_OLD_NOT_STORED;
 
646
 
 
647
        cursor->latch_mode = BTR_NO_LATCHES;
 
648
        cursor->pos_state = BTR_PCUR_NOT_POSITIONED;
 
649
 
 
650
        cursor->trx_if_known = NULL;
 
651
}