bt_utils.c (1573) | bt_utils.c (14272) |
---|---|
1/*- | 1/*- |
2 * Copyright (c) 1990, 1993 | 2 * Copyright (c) 1990, 1993, 1994 |
3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Mike Olson. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: --- 19 unchanged lines hidden (view full) --- 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 */ 36 37#if defined(LIBC_SCCS) && !defined(lint) | 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Mike Olson. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: --- 19 unchanged lines hidden (view full) --- 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 */ 36 37#if defined(LIBC_SCCS) && !defined(lint) |
38static char sccsid[] = "@(#)bt_utils.c 8.4 (Berkeley) 2/21/94"; | 38static char sccsid[] = "@(#)bt_utils.c 8.8 (Berkeley) 7/20/94"; |
39#endif /* LIBC_SCCS and not lint */ 40 41#include <sys/param.h> 42 43#include <stdio.h> 44#include <stdlib.h> 45#include <string.h> 46 47#include <db.h> 48#include "btree.h" 49 50/* | 39#endif /* LIBC_SCCS and not lint */ 40 41#include <sys/param.h> 42 43#include <stdio.h> 44#include <stdlib.h> 45#include <string.h> 46 47#include <db.h> 48#include "btree.h" 49 50/* |
51 * __BT_RET -- Build return key/data pair as a result of search or scan. | 51 * __bt_ret -- 52 * Build return key/data pair. |
52 * 53 * Parameters: 54 * t: tree | 53 * 54 * Parameters: 55 * t: tree |
55 * d: LEAF to be returned to the user. | 56 * e: key/data pair to be returned |
56 * key: user's key structure (NULL if not to be filled in) | 57 * key: user's key structure (NULL if not to be filled in) |
57 * data: user's data structure | 58 * rkey: memory area to hold key 59 * data: user's data structure (NULL if not to be filled in) 60 * rdata: memory area to hold data 61 * copy: always copy the key/data item |
58 * 59 * Returns: 60 * RET_SUCCESS, RET_ERROR. 61 */ 62int | 62 * 63 * Returns: 64 * RET_SUCCESS, RET_ERROR. 65 */ 66int |
63__bt_ret(t, e, key, data) | 67__bt_ret(t, e, key, rkey, data, rdata, copy) |
64 BTREE *t; 65 EPG *e; | 68 BTREE *t; 69 EPG *e; |
66 DBT *key, *data; | 70 DBT *key, *rkey, *data, *rdata; 71 int copy; |
67{ | 72{ |
68 register BLEAF *bl; 69 register void *p; | 73 BLEAF *bl; 74 void *p; |
70 71 bl = GETBLEAF(e->page, e->index); 72 73 /* | 75 76 bl = GETBLEAF(e->page, e->index); 77 78 /* |
74 * We always copy big keys/data to make them contigous. Otherwise, 75 * we leave the page pinned and don't copy unless the user specified | 79 * We must copy big keys/data to make them contigous. Otherwise, 80 * leave the page pinned and don't copy unless the user specified |
76 * concurrent access. 77 */ | 81 * concurrent access. 82 */ |
78 if (bl->flags & P_BIGDATA) { 79 if (__ovfl_get(t, bl->bytes + bl->ksize, 80 &data->size, &t->bt_dbuf, &t->bt_dbufsz)) | 83 if (key == NULL) 84 goto dataonly; 85 86 if (bl->flags & P_BIGKEY) { 87 if (__ovfl_get(t, bl->bytes, 88 &key->size, &rkey->data, &rkey->size)) |
81 return (RET_ERROR); | 89 return (RET_ERROR); |
82 data->data = t->bt_dbuf; 83 } else if (ISSET(t, B_DB_LOCK)) { 84 /* Use +1 in case the first record retrieved is 0 length. */ 85 if (bl->dsize + 1 > t->bt_dbufsz) { 86 if ((p = 87 (void *)realloc(t->bt_dbuf, bl->dsize + 1)) == NULL) | 90 key->data = rkey->data; 91 } else if (copy || F_ISSET(t, B_DB_LOCK)) { 92 if (bl->ksize > rkey->size) { 93 p = (void *)(rkey->data == NULL ? 94 malloc(bl->ksize) : realloc(rkey->data, bl->ksize)); 95 if (p == NULL) |
88 return (RET_ERROR); | 96 return (RET_ERROR); |
89 t->bt_dbuf = p; 90 t->bt_dbufsz = bl->dsize + 1; | 97 rkey->data = p; 98 rkey->size = bl->ksize; |
91 } | 99 } |
92 memmove(t->bt_dbuf, bl->bytes + bl->ksize, bl->dsize); 93 data->size = bl->dsize; 94 data->data = t->bt_dbuf; | 100 memmove(rkey->data, bl->bytes, bl->ksize); 101 key->size = bl->ksize; 102 key->data = rkey->data; |
95 } else { | 103 } else { |
96 data->size = bl->dsize; 97 data->data = bl->bytes + bl->ksize; | 104 key->size = bl->ksize; 105 key->data = bl->bytes; |
98 } 99 | 106 } 107 |
100 if (key == NULL) | 108dataonly: 109 if (data == NULL) |
101 return (RET_SUCCESS); 102 | 110 return (RET_SUCCESS); 111 |
103 if (bl->flags & P_BIGKEY) { 104 if (__ovfl_get(t, bl->bytes, 105 &key->size, &t->bt_kbuf, &t->bt_kbufsz)) | 112 if (bl->flags & P_BIGDATA) { 113 if (__ovfl_get(t, bl->bytes + bl->ksize, 114 &data->size, &rdata->data, &rdata->size)) |
106 return (RET_ERROR); | 115 return (RET_ERROR); |
107 key->data = t->bt_kbuf; 108 } else if (ISSET(t, B_DB_LOCK)) { 109 if (bl->ksize > t->bt_kbufsz) { 110 if ((p = 111 (void *)realloc(t->bt_kbuf, bl->ksize)) == NULL) | 116 data->data = rdata->data; 117 } else if (copy || F_ISSET(t, B_DB_LOCK)) { 118 /* Use +1 in case the first record retrieved is 0 length. */ 119 if (bl->dsize + 1 > rdata->size) { 120 p = (void *)(rdata->data == NULL ? 121 malloc(bl->dsize + 1) : 122 realloc(rdata->data, bl->dsize + 1)); 123 if (p == NULL) |
112 return (RET_ERROR); | 124 return (RET_ERROR); |
113 t->bt_kbuf = p; 114 t->bt_kbufsz = bl->ksize; | 125 rdata->data = p; 126 rdata->size = bl->dsize + 1; |
115 } | 127 } |
116 memmove(t->bt_kbuf, bl->bytes, bl->ksize); 117 key->size = bl->ksize; 118 key->data = t->bt_kbuf; | 128 memmove(rdata->data, bl->bytes + bl->ksize, bl->dsize); 129 data->size = bl->dsize; 130 data->data = rdata->data; |
119 } else { | 131 } else { |
120 key->size = bl->ksize; 121 key->data = bl->bytes; | 132 data->size = bl->dsize; 133 data->data = bl->bytes + bl->ksize; |
122 } | 134 } |
135 |
|
123 return (RET_SUCCESS); 124} 125 126/* 127 * __BT_CMP -- Compare a key to a given record. 128 * 129 * Parameters: 130 * t: tree --- 44 unchanged lines hidden (view full) --- 175 else { 176 k2.data = bi->bytes; 177 k2.size = bi->ksize; 178 } 179 } 180 181 if (bigkey) { 182 if (__ovfl_get(t, bigkey, | 136 return (RET_SUCCESS); 137} 138 139/* 140 * __BT_CMP -- Compare a key to a given record. 141 * 142 * Parameters: 143 * t: tree --- 44 unchanged lines hidden (view full) --- 188 else { 189 k2.data = bi->bytes; 190 k2.size = bi->ksize; 191 } 192 } 193 194 if (bigkey) { 195 if (__ovfl_get(t, bigkey, |
183 &k2.size, &t->bt_dbuf, &t->bt_dbufsz)) | 196 &k2.size, &t->bt_rdata.data, &t->bt_rdata.size)) |
184 return (RET_ERROR); | 197 return (RET_ERROR); |
185 k2.data = t->bt_dbuf; | 198 k2.data = t->bt_rdata.data; |
186 } 187 return ((*t->bt_cmp)(k1, &k2)); 188} 189 190/* 191 * __BT_DEFCMP -- Default comparison routine. 192 * 193 * Parameters: --- 54 unchanged lines hidden --- | 199 } 200 return ((*t->bt_cmp)(k1, &k2)); 201} 202 203/* 204 * __BT_DEFCMP -- Default comparison routine. 205 * 206 * Parameters: --- 54 unchanged lines hidden --- |