1 #pragma ident "%Z%%M% %I% %E% SMI"
2
3 /*-
4 * Copyright (c) 1990, 1993, 1994
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by the University of
18 * California, Berkeley and its contributors.
19 * 4. Neither the name of the University nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36 #if defined(LIBC_SCCS) && !defined(lint)
37 static char sccsid[] = "@(#)rec_get.c 8.9 (Berkeley) 8/18/94";
38 #endif /* LIBC_SCCS and not lint */
39
40 #include <sys/types.h>
41
42 #include <errno.h>
43 #include <stddef.h>
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <string.h>
47 #include <unistd.h>
48
49 #include "db-int.h"
50 #include "recno.h"
51
52 /*
53 * __REC_GET -- Get a record from the btree.
54 *
55 * Parameters:
56 * dbp: pointer to access method
57 * key: key to find
58 * data: data to return
59 * flag: currently unused
60 *
61 * Returns:
62 * RET_ERROR, RET_SUCCESS and RET_SPECIAL if the key not found.
63 */
64 int
__rec_get(dbp,key,data,flags)65 __rec_get(dbp, key, data, flags)
66 const DB *dbp;
67 const DBT *key;
68 DBT *data;
69 u_int flags;
70 {
71 BTREE *t;
72 EPG *e;
73 recno_t nrec;
74 int status;
75
76 t = dbp->internal;
77
78 /* Toss any page pinned across calls. */
79 if (t->bt_pinned != NULL) {
80 mpool_put(t->bt_mp, t->bt_pinned, 0);
81 t->bt_pinned = NULL;
82 }
83
84 /* Get currently doesn't take any flags, and keys of 0 are illegal. */
85 if (flags || (nrec = *(recno_t *)key->data) == 0) {
86 errno = EINVAL;
87 return (RET_ERROR);
88 }
89
90 /*
91 * If we haven't seen this record yet, try to find it in the
92 * original file.
93 */
94 if (nrec > t->bt_nrecs) {
95 if (F_ISSET(t, R_EOF | R_INMEM))
96 return (RET_SPECIAL);
97 if ((status = t->bt_irec(t, nrec)) != RET_SUCCESS)
98 return (status);
99 }
100
101 --nrec;
102 if ((e = __rec_search(t, nrec, SEARCH)) == NULL)
103 return (RET_ERROR);
104
105 status = __rec_ret(t, e, 0, NULL, data);
106 if (F_ISSET(t, B_DB_LOCK))
107 mpool_put(t->bt_mp, e->page, 0);
108 else
109 t->bt_pinned = e->page;
110 return (status);
111 }
112
113 /*
114 * __REC_FPIPE -- Get fixed length records from a pipe.
115 *
116 * Parameters:
117 * t: tree
118 * cnt: records to read
119 *
120 * Returns:
121 * RET_ERROR, RET_SUCCESS
122 */
123 int
__rec_fpipe(t,top)124 __rec_fpipe(t, top)
125 BTREE *t;
126 recno_t top;
127 {
128 DBT data;
129 recno_t nrec;
130 size_t len;
131 int ch;
132 u_char *p;
133
134 if (t->bt_rdata.size < t->bt_reclen) {
135 t->bt_rdata.data = t->bt_rdata.data == NULL ?
136 malloc(t->bt_reclen) :
137 realloc(t->bt_rdata.data, t->bt_reclen);
138 if (t->bt_rdata.data == NULL)
139 return (RET_ERROR);
140 t->bt_rdata.size = t->bt_reclen;
141 }
142 data.data = t->bt_rdata.data;
143 data.size = t->bt_reclen;
144
145 for (nrec = t->bt_nrecs; nrec < top;) {
146 len = t->bt_reclen;
147 for (p = t->bt_rdata.data;; *p++ = ch)
148 if ((ch = getc(t->bt_rfp)) == EOF || !--len) {
149 if (ch != EOF)
150 *p = ch;
151 if (len != 0)
152 memset(p, t->bt_bval, len);
153 if (__rec_iput(t,
154 nrec, &data, 0) != RET_SUCCESS)
155 return (RET_ERROR);
156 ++nrec;
157 break;
158 }
159 if (ch == EOF)
160 break;
161 }
162 if (nrec < top) {
163 F_SET(t, R_EOF);
164 return (RET_SPECIAL);
165 }
166 return (RET_SUCCESS);
167 }
168
169 /*
170 * __REC_VPIPE -- Get variable length records from a pipe.
171 *
172 * Parameters:
173 * t: tree
174 * cnt: records to read
175 *
176 * Returns:
177 * RET_ERROR, RET_SUCCESS
178 */
179 int
__rec_vpipe(t,top)180 __rec_vpipe(t, top)
181 BTREE *t;
182 recno_t top;
183 {
184 DBT data;
185 recno_t nrec;
186 indx_t len;
187 size_t sz;
188 int bval, ch;
189 u_char *p;
190
191 bval = t->bt_bval;
192 for (nrec = t->bt_nrecs; nrec < top; ++nrec) {
193 for (p = t->bt_rdata.data,
194 sz = t->bt_rdata.size;; *p++ = ch, --sz) {
195 if ((ch = getc(t->bt_rfp)) == EOF || ch == bval) {
196 data.data = t->bt_rdata.data;
197 data.size = p - (u_char *)t->bt_rdata.data;
198 if (ch == EOF && data.size == 0)
199 break;
200 if (__rec_iput(t, nrec, &data, 0)
201 != RET_SUCCESS)
202 return (RET_ERROR);
203 break;
204 }
205 if (sz == 0) {
206 len = p - (u_char *)t->bt_rdata.data;
207 t->bt_rdata.size += (sz = 256);
208 t->bt_rdata.data = t->bt_rdata.data == NULL ?
209 malloc(t->bt_rdata.size) :
210 realloc(t->bt_rdata.data, t->bt_rdata.size);
211 if (t->bt_rdata.data == NULL)
212 return (RET_ERROR);
213 p = (u_char *)t->bt_rdata.data + len;
214 }
215 }
216 if (ch == EOF)
217 break;
218 }
219 if (nrec < top) {
220 F_SET(t, R_EOF);
221 return (RET_SPECIAL);
222 }
223 return (RET_SUCCESS);
224 }
225
226 /*
227 * __REC_FMAP -- Get fixed length records from a file.
228 *
229 * Parameters:
230 * t: tree
231 * cnt: records to read
232 *
233 * Returns:
234 * RET_ERROR, RET_SUCCESS
235 */
236 int
__rec_fmap(t,top)237 __rec_fmap(t, top)
238 BTREE *t;
239 recno_t top;
240 {
241 DBT data;
242 recno_t nrec;
243 u_char *sp, *ep, *p;
244 size_t len;
245
246 if (t->bt_rdata.size < t->bt_reclen) {
247 t->bt_rdata.data = t->bt_rdata.data == NULL ?
248 malloc(t->bt_reclen) :
249 realloc(t->bt_rdata.data, t->bt_reclen);
250 if (t->bt_rdata.data == NULL)
251 return (RET_ERROR);
252 t->bt_rdata.size = t->bt_reclen;
253 }
254 data.data = t->bt_rdata.data;
255 data.size = t->bt_reclen;
256
257 sp = (u_char *)t->bt_cmap;
258 ep = (u_char *)t->bt_emap;
259 for (nrec = t->bt_nrecs; nrec < top; ++nrec) {
260 if (sp >= ep) {
261 F_SET(t, R_EOF);
262 return (RET_SPECIAL);
263 }
264 len = t->bt_reclen;
265 for (p = t->bt_rdata.data;
266 sp < ep && len > 0; *p++ = *sp++, --len);
267 if (len != 0)
268 memset(p, t->bt_bval, len);
269 if (__rec_iput(t, nrec, &data, 0) != RET_SUCCESS)
270 return (RET_ERROR);
271 }
272 t->bt_cmap = (caddr_t)sp;
273 return (RET_SUCCESS);
274 }
275
276 /*
277 * __REC_VMAP -- Get variable length records from a file.
278 *
279 * Parameters:
280 * t: tree
281 * cnt: records to read
282 *
283 * Returns:
284 * RET_ERROR, RET_SUCCESS
285 */
286 int
__rec_vmap(t,top)287 __rec_vmap(t, top)
288 BTREE *t;
289 recno_t top;
290 {
291 DBT data;
292 u_char *sp, *ep;
293 recno_t nrec;
294 int bval;
295
296 sp = (u_char *)t->bt_cmap;
297 ep = (u_char *)t->bt_emap;
298 bval = t->bt_bval;
299
300 for (nrec = t->bt_nrecs; nrec < top; ++nrec) {
301 if (sp >= ep) {
302 F_SET(t, R_EOF);
303 return (RET_SPECIAL);
304 }
305 for (data.data = sp; sp < ep && *sp != bval; ++sp);
306 data.size = sp - (u_char *)data.data;
307 if (__rec_iput(t, nrec, &data, 0) != RET_SUCCESS)
308 return (RET_ERROR);
309 ++sp;
310 }
311 t->bt_cmap = (caddr_t)sp;
312 return (RET_SUCCESS);
313 }
314