Asterisk - The Open Source Telephony Project GIT-master-f3e88d3
Functions
bt_delete.c File Reference
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include "../include/db.h"
#include "btree.h"
Include dependency graph for bt_delete.c:

Go to the source code of this file.

Functions

static int __bt_bdelete (BTREE *t, const DBT *key)
 
static int __bt_curdel (BTREE *t, const DBT *key, PAGE *h, u_int idx)
 
int __bt_delete (DB *dbp, const DBT *key, u_int flags) const
 
int __bt_dleaf (BTREE *t, const DBT *key, PAGE *h, u_int idx)
 
static int __bt_pdelete (BTREE *t, PAGE *h)
 
static int __bt_relink (BTREE *t, PAGE *h)
 
static int __bt_stkacq (BTREE *t, PAGE **hp, CURSOR *c)
 
static int __bt_bdelete __P ((BTREE *, const DBT *))
 
static int __bt_curdel __P ((BTREE *, const DBT *, PAGE *, u_int))
 
static int __bt_pdelete __P ((BTREE *, PAGE *))
 
static int __bt_stkacq __P ((BTREE *, PAGE **, CURSOR *))
 

Function Documentation

◆ __bt_bdelete()

static int __bt_bdelete ( BTREE t,
const DBT key 
)
static

Definition at line 291 of file bt_delete.c.

294{
295 EPG *e;
296 PAGE *h;
297 int deleted, exact, redo;
298
299 deleted = 0;
300
301 /* Find any matching record; __bt_search pins the page. */
302loop: if ((e = __bt_search(t, key, &exact)) == NULL)
303 return (deleted ? RET_SUCCESS : RET_ERROR);
304 if (!exact) {
305 mpool_put(t->bt_mp, e->page, 0);
306 return (deleted ? RET_SUCCESS : RET_SPECIAL);
307 }
308
309 /*
310 * Delete forward, then delete backward, from the found key. If
311 * there are duplicates and we reach either side of the page, do
312 * the key search again, so that we get them all.
313 */
314 redo = 0;
315 h = e->page;
316 do {
317 if (__bt_dleaf(t, key, h, e->index)) {
318 mpool_put(t->bt_mp, h, 0);
319 return (RET_ERROR);
320 }
321 if (F_ISSET(t, B_NODUPS)) {
322 if (NEXTINDEX(h) == 0) {
323 if (__bt_pdelete(t, h))
324 return (RET_ERROR);
325 } else
327 return (RET_SUCCESS);
328 }
329 deleted = 1;
330 } while (e->index < NEXTINDEX(h) && __bt_cmp(t, key, e) == 0);
331
332 /* Check for right-hand edge of the page. */
333 if (e->index == NEXTINDEX(h))
334 redo = 1;
335
336 /* Delete from the key to the beginning of the page. */
337 while (e->index-- > 0) {
338 if (__bt_cmp(t, key, e) != 0)
339 break;
340 if (__bt_dleaf(t, key, h, e->index) == RET_ERROR) {
341 mpool_put(t->bt_mp, h, 0);
342 return (RET_ERROR);
343 }
344 if (e->index == 0)
345 redo = 1;
346 }
347
348 /* Check for an empty page. */
349 if (NEXTINDEX(h) == 0) {
350 if (__bt_pdelete(t, h))
351 return (RET_ERROR);
352 goto loop;
353 }
354
355 /* Put the page. */
357
358 if (redo)
359 goto loop;
360 return (RET_SUCCESS);
361}
int __bt_dleaf(BTREE *t, const DBT *key, PAGE *h, u_int idx)
Definition: bt_delete.c:474
static int __bt_pdelete(BTREE *t, PAGE *h)
Definition: bt_delete.c:378
EPG * __bt_search(BTREE *t, const DBT *key, int *exactp)
Definition: bt_search.c:66
int __bt_cmp(BTREE *t, const DBT *k1, EPG *e)
Definition: bt_utils.c:153
#define F_ISSET(p, f)
Definition: btree.h:42
#define B_NODUPS
Definition: btree.h:374
#define NEXTINDEX(p)
Definition: btree.h:98
#define RET_SUCCESS
Definition: db.h:52
#define RET_ERROR
Definition: db.h:51
#define RET_SPECIAL
Definition: db.h:53
int mpool_put(MPOOL *mp, void *page, u_int flags)
Definition: mpool.c:251
#define MPOOL_DIRTY
Definition: mpool.h:61
#define NULL
Definition: resample.c:96
MPOOL * bt_mp
Definition: btree.h:313
Definition: btree.h:254
indx_t index
Definition: btree.h:256
PAGE * page
Definition: btree.h:255
Definition: btree.h:75

References __bt_cmp(), __bt_dleaf(), __bt_pdelete(), __bt_search(), B_NODUPS, _btree::bt_mp, F_ISSET, _epg::index, MPOOL_DIRTY, mpool_put(), NEXTINDEX, NULL, _epg::page, RET_ERROR, RET_SPECIAL, and RET_SUCCESS.

Referenced by __bt_delete().

◆ __bt_curdel()

static int __bt_curdel ( BTREE t,
const DBT key,
PAGE h,
u_int  idx 
)
static

Definition at line 539 of file bt_delete.c.

544{
545 CURSOR *c;
546 EPG e;
547 PAGE *pg;
548 int curcopy, status;
549
550 /*
551 * If there are duplicates, move forward or backward to one.
552 * Otherwise, copy the key into the cursor area.
553 */
554 c = &t->bt_cursor;
556
557 curcopy = 0;
558 if (!F_ISSET(t, B_NODUPS)) {
559 /*
560 * We're going to have to do comparisons. If we weren't
561 * provided a copy of the key, i.e. the user is deleting
562 * the current cursor position, get one.
563 */
564 if (key == NULL) {
565 e.page = h;
566 e.index = idx;
567 if ((status = __bt_ret(t, &e,
568 &c->key, &c->key, NULL, NULL, 1)) != RET_SUCCESS)
569 return (status);
570 curcopy = 1;
571 key = &c->key;
572 }
573 /* Check previous key, if not at the beginning of the page. */
574 if (idx > 0) {
575 e.page = h;
576 e.index = idx - 1;
577 if (__bt_cmp(t, key, &e) == 0) {
579 goto dup2;
580 }
581 }
582 /* Check next key, if not at the end of the page. */
583 if (idx < NEXTINDEX(h) - 1) {
584 e.page = h;
585 e.index = idx + 1;
586 if (__bt_cmp(t, key, &e) == 0) {
588 goto dup2;
589 }
590 }
591 /* Check previous key if at the beginning of the page. */
592 if (idx == 0 && h->prevpg != P_INVALID) {
593 if ((pg = mpool_get(t->bt_mp, h->prevpg, 0)) == NULL)
594 return (RET_ERROR);
595 e.page = pg;
596 e.index = NEXTINDEX(pg) - 1;
597 if (__bt_cmp(t, key, &e) == 0) {
599 goto dup1;
600 }
601 mpool_put(t->bt_mp, pg, 0);
602 }
603 /* Check next key if at the end of the page. */
604 if (idx == NEXTINDEX(h) - 1 && h->nextpg != P_INVALID) {
605 if ((pg = mpool_get(t->bt_mp, h->nextpg, 0)) == NULL)
606 return (RET_ERROR);
607 e.page = pg;
608 e.index = 0;
609 if (__bt_cmp(t, key, &e) == 0) {
611dup1: mpool_put(t->bt_mp, pg, 0);
612dup2: c->pg.pgno = e.page->pgno;
613 c->pg.index = e.index;
614 return (RET_SUCCESS);
615 }
616 mpool_put(t->bt_mp, pg, 0);
617 }
618 }
619 e.page = h;
620 e.index = idx;
621 if (curcopy || (status =
622 __bt_ret(t, &e, &c->key, &c->key, NULL, NULL, 1)) == RET_SUCCESS) {
624 return (RET_SUCCESS);
625 }
626 return (status);
627}
jack_status_t status
Definition: app_jack.c:146
int __bt_ret(BTREE *t, EPG *e, DBT *key, DBT *rkey, DBT *data, DBT *rdata, int copy)
Definition: bt_utils.c:67
#define CURS_AFTER
Definition: btree.h:289
#define CURS_ACQUIRE
Definition: btree.h:288
#define F_SET(p, f)
Definition: btree.h:40
#define P_INVALID
Definition: btree.h:63
#define F_CLR(p, f)
Definition: btree.h:41
#define CURS_BEFORE
Definition: btree.h:290
void * mpool_get(MPOOL *mp, pgno_t pgno, u_int flags)
Definition: mpool.c:165
CURSOR bt_cursor
Definition: btree.h:320
Definition: btree.h:283
pgno_t prevpg
Definition: btree.h:77
pgno_t pgno
Definition: btree.h:76
pgno_t nextpg
Definition: btree.h:78
static struct test_val c

References __bt_cmp(), __bt_ret(), B_NODUPS, _btree::bt_cursor, _btree::bt_mp, c, CURS_ACQUIRE, CURS_AFTER, CURS_BEFORE, F_CLR, F_ISSET, F_SET, _epg::index, mpool_get(), mpool_put(), NEXTINDEX, _page::nextpg, NULL, P_INVALID, _epg::page, _page::pgno, _page::prevpg, RET_ERROR, RET_SUCCESS, and status.

Referenced by __bt_dleaf().

◆ __bt_delete()

int __bt_delete ( DB dbp,
const DBT key,
u_int  flags 
) const

Definition at line 63 of file bt_delete.c.

67{
68 BTREE *t;
69 CURSOR *c;
70 PAGE *h;
71 int status;
72
73 t = dbp->internal;
74
75 /* Toss any page pinned across calls. */
76 if (t->bt_pinned != NULL) {
77 mpool_put(t->bt_mp, t->bt_pinned, 0);
78 t->bt_pinned = NULL;
79 }
80
81 /* Check for change to a read-only tree. */
82 if (F_ISSET(t, B_RDONLY)) {
83 errno = EPERM;
84 return (RET_ERROR);
85 }
86
87 switch (flags) {
88 case 0:
89 status = __bt_bdelete(t, key);
90 break;
91 case R_CURSOR:
92 /*
93 * If flags is R_CURSOR, delete the cursor. Must already
94 * have started a scan and not have already deleted it.
95 */
96 c = &t->bt_cursor;
97 if (F_ISSET(c, CURS_INIT)) {
99 return (RET_SPECIAL);
100 if ((h = mpool_get(t->bt_mp, c->pg.pgno, 0)) == NULL)
101 return (RET_ERROR);
102
103 /*
104 * If the page is about to be emptied, we'll need to
105 * delete it, which means we have to acquire a stack.
106 */
107 if (NEXTINDEX(h) == 1)
108 if (__bt_stkacq(t, &h, &t->bt_cursor))
109 return (RET_ERROR);
110
111 status = __bt_dleaf(t, NULL, h, c->pg.index);
112
113 if (NEXTINDEX(h) == 0 && status == RET_SUCCESS) {
114 if (__bt_pdelete(t, h))
115 return (RET_ERROR);
116 } else
117 mpool_put(t->bt_mp,
118 h, status == RET_SUCCESS ? MPOOL_DIRTY : 0);
119 break;
120 }
121 /* FALLTHROUGH */
122 default:
123 errno = EINVAL;
124 return (RET_ERROR);
125 }
126 if (status == RET_SUCCESS)
127 F_SET(t, B_MODIFIED);
128 return (status);
129}
static int __bt_stkacq(BTREE *t, PAGE **hp, CURSOR *c)
Definition: bt_delete.c:144
static int __bt_bdelete(BTREE *t, const DBT *key)
Definition: bt_delete.c:291
#define B_MODIFIED
Definition: btree.h:370
#define B_RDONLY
Definition: btree.h:372
#define CURS_INIT
Definition: btree.h:291
#define R_CURSOR
Definition: db.h:91
static DB * dbp
Definition: hsearch.c:49
int errno
void * internal
Definition: db.h:137
Definition: btree.h:312
PAGE * bt_pinned
Definition: btree.h:318

References __bt_bdelete(), __bt_dleaf(), __bt_pdelete(), __bt_stkacq(), B_MODIFIED, B_RDONLY, _btree::bt_cursor, _btree::bt_mp, _btree::bt_pinned, c, CURS_ACQUIRE, CURS_AFTER, CURS_BEFORE, CURS_INIT, dbp, errno, F_ISSET, F_SET, __db::internal, MPOOL_DIRTY, mpool_get(), mpool_put(), NEXTINDEX, NULL, R_CURSOR, RET_ERROR, RET_SPECIAL, RET_SUCCESS, and status.

Referenced by __bt_open().

◆ __bt_dleaf()

int __bt_dleaf ( BTREE t,
const DBT key,
PAGE h,
u_int  idx 
)

Definition at line 474 of file bt_delete.c.

479{
480 BLEAF *bl;
481 indx_t cnt, *ip, offset;
482 u_int32_t nbytes;
483 void *to;
484 char *from;
485
486 /* If this record is referenced by the cursor, delete the cursor. */
487 if (F_ISSET(&t->bt_cursor, CURS_INIT) &&
489 t->bt_cursor.pg.pgno == h->pgno && t->bt_cursor.pg.index == idx &&
490 __bt_curdel(t, key, h, idx))
491 return (RET_ERROR);
492
493 /* If the entry uses overflow pages, make them available for reuse. */
494 to = bl = GETBLEAF(h, idx);
495 if (bl->flags & P_BIGKEY && __ovfl_delete(t, bl->bytes) == RET_ERROR)
496 return (RET_ERROR);
497 if (bl->flags & P_BIGDATA &&
498 __ovfl_delete(t, bl->bytes + bl->ksize) == RET_ERROR)
499 return (RET_ERROR);
500
501 /* Pack the remaining key/data items at the end of the page. */
502 nbytes = NBLEAF(bl);
503 from = (char *)h + h->upper;
504 memmove(from + nbytes, from, (char *)to - from);
505 h->upper += nbytes;
506
507 /* Adjust the indices' offsets, shift the indices down. */
508 offset = h->linp[idx];
509 for (cnt = idx, ip = &h->linp[0]; cnt--; ++ip)
510 if (ip[0] < offset)
511 ip[0] += nbytes;
512 for (cnt = NEXTINDEX(h) - idx; --cnt; ++ip)
513 ip[0] = ip[1] < offset ? ip[1] + nbytes : ip[1];
514 h->lower -= sizeof(indx_t);
515
516 /* If the cursor is on this page, adjust it as necessary. */
517 if (F_ISSET(&t->bt_cursor, CURS_INIT) &&
519 t->bt_cursor.pg.pgno == h->pgno && t->bt_cursor.pg.index > idx)
520 --t->bt_cursor.pg.index;
521
522 return (RET_SUCCESS);
523}
static int __bt_curdel(BTREE *t, const DBT *key, PAGE *h, u_int idx)
Definition: bt_delete.c:539
int __ovfl_delete(BTREE *t, void *p)
Definition: bt_overflow.c:193
#define GETBLEAF(pg, indx)
Definition: btree.h:188
#define NBLEAF(p)
Definition: btree.h:192
#define P_BIGDATA
Definition: btree.h:131
#define P_BIGKEY
Definition: btree.h:132
u_int16_t indx_t
Definition: db.h:80
unsigned int u_int32_t
Definition: btree.h:180
u_char flags
Definition: btree.h:183
char bytes[1]
Definition: btree.h:184
u_int32_t ksize
Definition: btree.h:181
EPGNO pg
Definition: btree.h:284
pgno_t pgno
Definition: btree.h:250
indx_t index
Definition: btree.h:251
indx_t lower
Definition: btree.h:89
indx_t upper
Definition: btree.h:90
indx_t linp[1]
Definition: btree.h:91

References __bt_curdel(), __ovfl_delete(), _btree::bt_cursor, _bleaf::bytes, CURS_ACQUIRE, CURS_INIT, F_ISSET, _bleaf::flags, GETBLEAF, _epgno::index, _bleaf::ksize, _page::linp, _page::lower, NBLEAF, NEXTINDEX, P_BIGDATA, P_BIGKEY, _cursor::pg, _page::pgno, _epgno::pgno, RET_ERROR, RET_SUCCESS, and _page::upper.

Referenced by __bt_bdelete(), __bt_delete(), and __bt_put().

◆ __bt_pdelete()

static int __bt_pdelete ( BTREE t,
PAGE h 
)
static

Definition at line 378 of file bt_delete.c.

381{
382 BINTERNAL *bi;
383 PAGE *pg;
384 EPGNO *parent;
385 indx_t cnt, idx, *ip, offset;
386 u_int32_t nksize;
387 char *from;
388
389 /*
390 * Walk the parent page stack -- a LIFO stack of the pages that were
391 * traversed when we searched for the page where the delete occurred.
392 * Each stack entry is a page number and a page index offset. The
393 * offset is for the page traversed on the search. We've just deleted
394 * a page, so we have to delete the key from the parent page.
395 *
396 * If the delete from the parent page makes it empty, this process may
397 * continue all the way up the tree. We stop if we reach the root page
398 * (which is never deleted, it's just not worth the effort) or if the
399 * delete does not empty the page.
400 */
401 while ((parent = BT_POP(t)) != NULL) {
402 /* Get the parent page. */
403 if ((pg = mpool_get(t->bt_mp, parent->pgno, 0)) == NULL)
404 return (RET_ERROR);
405
406 idx = parent->index;
407 bi = GETBINTERNAL(pg, idx);
408
409 /* Free any overflow pages. */
410 if (bi->flags & P_BIGKEY &&
411 __ovfl_delete(t, bi->bytes) == RET_ERROR) {
412 mpool_put(t->bt_mp, pg, 0);
413 return (RET_ERROR);
414 }
415
416 /*
417 * Free the parent if it has only the one key and it's not the
418 * root page. If it's the rootpage, turn it back into an empty
419 * leaf page.
420 */
421 if (NEXTINDEX(pg) == 1) {
422 if (pg->pgno == P_ROOT) {
423 pg->lower = BTDATAOFF;
424 pg->upper = t->bt_psize;
425 pg->flags = P_BLEAF;
426 } else {
427 if (__bt_relink(t, pg) || __bt_free(t, pg))
428 return (RET_ERROR);
429 continue;
430 }
431 } else {
432 /* Pack remaining key items at the end of the page. */
433 nksize = NBINTERNAL(bi->ksize);
434 from = (char *)pg + pg->upper;
435 memmove(from + nksize, from, (char *)bi - from);
436 pg->upper += nksize;
437
438 /* Adjust indices' offsets, shift the indices down. */
439 offset = pg->linp[idx];
440 for (cnt = idx, ip = &pg->linp[0]; cnt--; ++ip)
441 if (ip[0] < offset)
442 ip[0] += nksize;
443 for (cnt = NEXTINDEX(pg) - idx; --cnt; ++ip)
444 ip[0] = ip[1] < offset ? ip[1] + nksize : ip[1];
445 pg->lower -= sizeof(indx_t);
446 }
447
448 mpool_put(t->bt_mp, pg, MPOOL_DIRTY);
449 break;
450 }
451
452 /* Free the leaf page, as long as it wasn't the root. */
453 if (h->pgno == P_ROOT) {
455 return (RET_SUCCESS);
456 }
457 return (__bt_relink(t, h) || __bt_free(t, h));
458}
static int __bt_relink(BTREE *t, PAGE *h)
Definition: bt_delete.c:638
int __bt_free(BTREE *t, PAGE *h)
Definition: bt_page.c:60
#define GETBINTERNAL(pg, indx)
Definition: btree.h:138
#define NBINTERNAL(len)
Definition: btree.h:142
#define BT_POP(t)
Definition: btree.h:327
#define P_BLEAF
Definition: btree.h:81
#define BTDATAOFF
Definition: btree.h:95
#define P_ROOT
Definition: btree.h:65
u_char flags
Definition: btree.h:133
char bytes[1]
Definition: btree.h:134
u_int32_t ksize
Definition: btree.h:129
u_int32_t bt_psize
Definition: btree.h:338
Definition: btree.h:249
u_int32_t flags
Definition: btree.h:87

References __bt_free(), __bt_relink(), __ovfl_delete(), _btree::bt_mp, BT_POP, _btree::bt_psize, BTDATAOFF, _binternal::bytes, _page::flags, _binternal::flags, GETBINTERNAL, _epgno::index, _binternal::ksize, _page::linp, _page::lower, MPOOL_DIRTY, mpool_get(), mpool_put(), NBINTERNAL, NEXTINDEX, NULL, P_BIGKEY, P_BLEAF, P_ROOT, _page::pgno, _epgno::pgno, RET_ERROR, RET_SUCCESS, and _page::upper.

Referenced by __bt_bdelete(), and __bt_delete().

◆ __bt_relink()

static int __bt_relink ( BTREE t,
PAGE h 
)
static

Definition at line 638 of file bt_delete.c.

641{
642 PAGE *pg;
643
644 if (h->nextpg != P_INVALID) {
645 if ((pg = mpool_get(t->bt_mp, h->nextpg, 0)) == NULL)
646 return (RET_ERROR);
647 pg->prevpg = h->prevpg;
648 mpool_put(t->bt_mp, pg, MPOOL_DIRTY);
649 }
650 if (h->prevpg != P_INVALID) {
651 if ((pg = mpool_get(t->bt_mp, h->prevpg, 0)) == NULL)
652 return (RET_ERROR);
653 pg->nextpg = h->nextpg;
654 mpool_put(t->bt_mp, pg, MPOOL_DIRTY);
655 }
656 return (0);
657}

References _btree::bt_mp, MPOOL_DIRTY, mpool_get(), mpool_put(), _page::nextpg, NULL, P_INVALID, _page::prevpg, and RET_ERROR.

Referenced by __bt_pdelete().

◆ __bt_stkacq()

static int __bt_stkacq ( BTREE t,
PAGE **  hp,
CURSOR c 
)
static

Definition at line 144 of file bt_delete.c.

148{
149 BINTERNAL *bi;
150 EPG *e;
151 EPGNO *parent;
152 PAGE *h;
153 indx_t idx = 0;
154 pgno_t pgno;
155 recno_t nextpg, prevpg;
156 int exact, level;
157
158 /*
159 * Find the first occurrence of the key in the tree. Toss the
160 * currently locked page so we don't hit an already-locked page.
161 */
162 h = *hp;
163 mpool_put(t->bt_mp, h, 0);
164 if ((e = __bt_search(t, &c->key, &exact)) == NULL)
165 return (1);
166 h = e->page;
167
168 /* See if we got it in one shot. */
169 if (h->pgno == c->pg.pgno)
170 goto ret;
171
172 /*
173 * Move right, looking for the page. At each move we have to move
174 * up the stack until we don't have to move to the next page. If
175 * we have to change pages at an internal level, we have to fix the
176 * stack back up.
177 */
178 while (h->pgno != c->pg.pgno) {
179 if ((nextpg = h->nextpg) == P_INVALID)
180 break;
181 mpool_put(t->bt_mp, h, 0);
182
183 /* Move up the stack. */
184 for (level = 0; (parent = BT_POP(t)) != NULL; ++level) {
185 /* Get the parent page. */
186 if ((h = mpool_get(t->bt_mp, parent->pgno, 0)) == NULL)
187 return (1);
188
189 /* Move to the next index. */
190 if (parent->index != NEXTINDEX(h) - 1) {
191 idx = parent->index + 1;
192 BT_PUSH(t, h->pgno, idx);
193 break;
194 }
195 mpool_put(t->bt_mp, h, 0);
196 }
197
198 /* Restore the stack. */
199 while (level--) {
200 /* Push the next level down onto the stack. */
201 bi = GETBINTERNAL(h, idx);
202 pgno = bi->pgno;
203 BT_PUSH(t, pgno, 0);
204
205 /* Lose the currently pinned page. */
206 mpool_put(t->bt_mp, h, 0);
207
208 /* Get the next level down. */
209 if ((h = mpool_get(t->bt_mp, pgno, 0)) == NULL)
210 return (1);
211 idx = 0;
212 }
213 mpool_put(t->bt_mp, h, 0);
214 if ((h = mpool_get(t->bt_mp, nextpg, 0)) == NULL)
215 return (1);
216 }
217
218 if (h->pgno == c->pg.pgno)
219 goto ret;
220
221 /* Reacquire the original stack. */
222 mpool_put(t->bt_mp, h, 0);
223 if ((e = __bt_search(t, &c->key, &exact)) == NULL)
224 return (1);
225 h = e->page;
226
227 /*
228 * Move left, looking for the page. At each move we have to move
229 * up the stack until we don't have to change pages to move to the
230 * next page. If we have to change pages at an internal level, we
231 * have to fix the stack back up.
232 */
233 while (h->pgno != c->pg.pgno) {
234 if ((prevpg = h->prevpg) == P_INVALID)
235 break;
236 mpool_put(t->bt_mp, h, 0);
237
238 /* Move up the stack. */
239 for (level = 0; (parent = BT_POP(t)) != NULL; ++level) {
240 /* Get the parent page. */
241 if ((h = mpool_get(t->bt_mp, parent->pgno, 0)) == NULL)
242 return (1);
243
244 /* Move to the next index. */
245 if (parent->index != 0) {
246 idx = parent->index - 1;
247 BT_PUSH(t, h->pgno, idx);
248 break;
249 }
250 mpool_put(t->bt_mp, h, 0);
251 }
252
253 /* Restore the stack. */
254 while (level--) {
255 /* Push the next level down onto the stack. */
256 bi = GETBINTERNAL(h, idx);
257 pgno = bi->pgno;
258
259 /* Lose the currently pinned page. */
260 mpool_put(t->bt_mp, h, 0);
261
262 /* Get the next level down. */
263 if ((h = mpool_get(t->bt_mp, pgno, 0)) == NULL)
264 return (1);
265
266 idx = NEXTINDEX(h) - 1;
267 BT_PUSH(t, pgno, idx);
268 }
269 mpool_put(t->bt_mp, h, 0);
270 if ((h = mpool_get(t->bt_mp, prevpg, 0)) == NULL)
271 return (1);
272 }
273
274
275ret: mpool_put(t->bt_mp, h, 0);
276 return ((*hp = mpool_get(t->bt_mp, c->pg.pgno, 0)) == NULL);
277}
#define BT_PUSH(t, p, i)
Definition: btree.h:322
u_int32_t recno_t
Definition: db.h:82
u_int32_t pgno_t
Definition: db.h:78
pgno_t pgno
Definition: btree.h:130

References __bt_search(), _btree::bt_mp, BT_POP, BT_PUSH, c, GETBINTERNAL, _epgno::index, mpool_get(), mpool_put(), NEXTINDEX, _page::nextpg, NULL, P_INVALID, _epg::page, _page::pgno, _binternal::pgno, _epgno::pgno, and _page::prevpg.

Referenced by __bt_delete().

◆ __P() [1/4]

static int __bt_bdelete __P ( (BTREE *, const DBT *)  )
static

◆ __P() [2/4]

static int __bt_curdel __P ( (BTREE *, const DBT *, PAGE *, u_int)  )
static

◆ __P() [3/4]

static int __bt_relink __P ( (BTREE *, PAGE *)  )
static

◆ __P() [4/4]

static int __bt_stkacq __P ( (BTREE *, PAGE **, CURSOR *)  )
static