bt_utils.c File Reference

#include <sys/param.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../include/db.h"
#include "btree.h"

Include dependency graph for bt_utils.c:

Go to the source code of this file.

Functions
int	__bt_cmp (BTREE *t, const DBT *k1, EPG *e)
int	__bt_defcmp (DBT *a, DBT *b) const
size_t	__bt_defpfx (DBT *a, DBT *b) const
int	__bt_ret (BTREE *t, EPG *e, DBT *key, DBT *rkey, DBT *data, DBT *rdata, int copy)

Function Documentation

__bt_cmp()

int __bt_cmp	(	BTREE *	t,
		const DBT *	k1,
		EPG *	e
	)

Definition at line 153 of file bt_utils.c.

References __ovfl_get(), _btree::bt_rdata, _binternal::bytes, _bleaf::bytes, DBT::data, _page::flags, _binternal::flags, _bleaf::flags, GETBINTERNAL, GETBLEAF, _epg::index, _binternal::ksize, _bleaf::ksize, NULL, P_BIGKEY, P_BLEAF, P_INVALID, _epg::page, _page::prevpg, RET_ERROR, and DBT::size.

Referenced by __bt_bdelete(), __bt_curdel(), __bt_first(), __bt_search(), __bt_snext(), __bt_sprev(), and bt_fast().

{
 BINTERNAL *bi;
 BLEAF *bl;
 DBT k2;
 PAGE *h;
 void *bigkey;

 /*
 * The left-most key on internal pages, at any level of the tree, is
 * guaranteed by the following code to be less than any user key.
 * This saves us from having to update the leftmost key on an internal
 * page when the user inserts a new key in the tree smaller than
 * anything we've yet seen.
 */
 h = e->page;
 if (e->index == 0 && h->prevpg == P_INVALID && !(h->flags & P_BLEAF))
 return (1);

 bigkey = NULL;
 if (h->flags & P_BLEAF) {
 bl = GETBLEAF(h, e->index);
 if (bl->flags & P_BIGKEY)
 bigkey = bl->bytes;
 else {
 k2.data = bl->bytes;
 k2.size = bl->ksize;
 }
 } else {
 bi = GETBINTERNAL(h, e->index);
 if (bi->flags & P_BIGKEY)
 bigkey = bi->bytes;
 else {
 k2.data = bi->bytes;
 k2.size = bi->ksize;
 }
 }

 if (bigkey) {
 if (__ovfl_get(t, bigkey,
 &k2.size, &t->bt_rdata.data, &t->bt_rdata.size))
 return (RET_ERROR);
 k2.data = t->bt_rdata.data;
 }
 return ((*t->bt_cmp)(k1, &k2));
}

__bt_defcmp()

int __bt_defcmp	(	DBT *	a,
		DBT *	b
	)		const

Definition at line 216 of file bt_utils.c.

References DBT::data, len(), MIN, and DBT::size.

Referenced by __bt_open().

{
 register size_t len;
 register u_char *p1, *p2;

 /*
 * XXX
 * If a size_t doesn't fit in an int, this routine can lose.
 * What we need is a integral type which is guaranteed to be
 * larger than a size_t, and there is no such thing.
 */
 len = MIN(a->size, b->size);
 for (p1 = a->data, p2 = b->data; len--; ++p1, ++p2)
 if (*p1 != *p2)
 return ((int)*p1 - (int)*p2);
 return ((int)a->size - (int)b->size);
}

__bt_defpfx()

size_t __bt_defpfx	(	DBT *	a,
		DBT *	b
	)		const

Definition at line 246 of file bt_utils.c.

References DBT::data, len(), MIN, and DBT::size.

Referenced by __bt_open().

{
 register u_char *p1, *p2;
 register size_t cnt, len;

 cnt = 1;
 len = MIN(a->size, b->size);
 for (p1 = a->data, p2 = b->data; len--; ++p1, ++p2, ++cnt)
 if (*p1 != *p2)
 return (cnt);

 /* a->size must be <= b->size, or they wouldn't be in this order. */
 return (a->size < b->size ? a->size + 1 : a->size);
}

__bt_ret()

int __bt_ret	(	BTREE *	t,
		EPG *	e,
		DBT *	key,
		DBT *	rkey,
		DBT *	data,
		DBT *	rdata,
		int	copy
	)

Definition at line 67 of file bt_utils.c.

References __ovfl_get(), B_DB_LOCK, _bleaf::bytes, copy(), DBT::data, _bleaf::dsize, F_ISSET, _bleaf::flags, GETBLEAF, _epg::index, _bleaf::ksize, malloc(), NULL, P_BIGDATA, P_BIGKEY, _epg::page, realloc, RET_ERROR, RET_SUCCESS, and DBT::size.

Referenced by __bt_curdel(), __bt_get(), and __bt_seq().

{
 BLEAF *bl;
 void *p;

 bl = GETBLEAF(e->page, e->index);

 /*
 * We must copy big keys/data to make them contiguous. Otherwise,
 * leave the page pinned and don't copy unless the user specified
 * concurrent access.
 */
 if (key == NULL)
 goto dataonly;

 if (bl->flags & P_BIGKEY) {
 if (__ovfl_get(t, bl->bytes,
 &key->size, &rkey->data, &rkey->size))
 return (RET_ERROR);
 key->data = rkey->data;
 } else if (copy || F_ISSET(t, B_DB_LOCK)) {
 if (bl->ksize > rkey->size) {
 p = (void *)(rkey->data == NULL ?
 malloc(bl->ksize) : realloc(rkey->data, bl->ksize));
 if (p == NULL)
 return (RET_ERROR);
 rkey->data = p;
 rkey->size = bl->ksize;
 }
 memmove(rkey->data, bl->bytes, bl->ksize);
 key->size = bl->ksize;
 key->data = rkey->data;
 } else {
 key->size = bl->ksize;
 key->data = bl->bytes;
 }

dataonly:
 if (data == NULL)
 return (RET_SUCCESS);

 if (bl->flags & P_BIGDATA) {
 if (__ovfl_get(t, bl->bytes + bl->ksize,
 &data->size, &rdata->data, &rdata->size))
 return (RET_ERROR);
 data->data = rdata->data;
 } else if (copy || F_ISSET(t, B_DB_LOCK)) {
 /* Use +1 in case the first record retrieved is 0 length. */
 if (bl->dsize + 1 > rdata->size) {
 p = (void *)(rdata->data == NULL ?
 malloc(bl->dsize + 1) :
 realloc(rdata->data, bl->dsize + 1));
 if (p == NULL)
 return (RET_ERROR);
 rdata->data = p;
 rdata->size = bl->dsize + 1;
 }
 memmove(rdata->data, bl->bytes + bl->ksize, bl->dsize);
 data->size = bl->dsize;
 data->data = rdata->data;
 } else {
 data->size = bl->dsize;
 data->data = bl->bytes + bl->ksize;
 }

 return (RET_SUCCESS);
}