1 /*-
2 * Copyright (c) 1992, 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1992, 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
6 *
7 * See the LICENSE file for redistribution information.
8 */
9
10 #include "config.h"
11
12 #include <sys/cdefs.h>
13 #if 0
14 #ifndef lint
15 static const char sccsid[] = "Id: db1.c,v 10.1 2002/03/09 12:53:57 skimo Exp (Berkeley) Date: 2002/03/09 12:53:57 ";
16 #endif /* not lint */
17 #else
18 __RCSID("$NetBSD: vi_db1.c,v 1.7 2014/01/26 21:43:45 christos Exp $");
19 #endif
20
21 #include <sys/types.h>
22 #include <sys/queue.h>
23 #include <sys/time.h>
24 #include <sys/stat.h>
25
26 #include <bitstring.h>
27 #include <errno.h>
28 #include <fcntl.h>
29 #include <limits.h>
30 #include <stdio.h>
31 #include <string.h>
32
33 #include "common.h"
34 #include "../vi/vi.h"
35 #include "dbinternal.h"
36
37 /*
38 * db_eget --
39 * Front-end to db_get, special case handling for empty files.
40 *
41 * PUBLIC: int db_eget __P((SCR *, db_recno_t, CHAR_T **, size_t *, int *));
42 */
43 int
db_eget(SCR * sp,db_recno_t lno,CHAR_T ** pp,size_t * lenp,int * isemptyp)44 db_eget(SCR *sp, db_recno_t lno, CHAR_T **pp, size_t *lenp, int *isemptyp)
45
46 /* Line number. */
47 /* Pointer store. */
48 /* Length store. */
49
50 {
51 db_recno_t l1;
52
53 if (isemptyp != NULL)
54 *isemptyp = 0;
55
56 /* If the line exists, simply return it. */
57 if (!db_get(sp, lno, 0, pp, lenp))
58 return (0);
59
60 /*
61 * If the user asked for line 0 or line 1, i.e. the only possible
62 * line in an empty file, find the last line of the file; db_last
63 * fails loudly.
64 */
65 if ((lno == 0 || lno == 1) && db_last(sp, &l1))
66 return (1);
67
68 /* If the file isn't empty, fail loudly. */
69 if ((lno != 0 && lno != 1) || l1 != 0) {
70 db_err(sp, lno);
71 return (1);
72 }
73
74 if (isemptyp != NULL)
75 *isemptyp = 1;
76
77 return (1);
78 }
79
80 /*
81 * db_get --
82 * Look in the text buffers for a line, followed by the cache, followed
83 * by the database.
84 *
85 * PUBLIC: int db_get __P((SCR *, db_recno_t, u_int32_t, CHAR_T **, size_t *));
86 */
87 int
db_get(SCR * sp,db_recno_t lno,u_int32_t flags,CHAR_T ** pp,size_t * lenp)88 db_get(SCR *sp, db_recno_t lno, u_int32_t flags, CHAR_T **pp, size_t *lenp)
89
90 /* Line number. */
91
92 /* Pointer store. */
93 /* Length store. */
94 {
95 DBT data, key;
96 EXF *ep;
97 TEXT *tp;
98 db_recno_t l1, l2;
99 const CHAR_T *wp;
100 size_t wlen;
101 size_t nlen;
102
103 /*
104 * The underlying recno stuff handles zero by returning NULL, but
105 * have to have an OOB condition for the look-aside into the input
106 * buffer anyway.
107 */
108 if (lno == 0)
109 goto err1;
110
111 /* Check for no underlying file. */
112 if ((ep = sp->ep) == NULL) {
113 ex_emsg(sp, NULL, EXM_NOFILEYET);
114 goto err3;
115 }
116
117 if (LF_ISSET(DBG_NOCACHE))
118 goto nocache;
119
120 /*
121 * Look-aside into the TEXT buffers and see if the line we want
122 * is there.
123 */
124 if (F_ISSET(sp, SC_TINPUT)) {
125 l1 = TAILQ_FIRST(&sp->tiq)->lno;
126 l2 = TAILQ_LAST(&sp->tiq, _texth)->lno;
127 if (l1 <= lno && l2 >= lno) {
128 #if defined(DBDEBUG) && defined(TRACE)
129 vtrace(
130 "retrieve TEXT buffer line %lu\n", (u_long)lno);
131 #endif
132 for (tp = TAILQ_FIRST(&sp->tiq);
133 tp->lno != lno; tp = TAILQ_NEXT(tp, q));
134 if (lenp != NULL)
135 *lenp = tp->len;
136 if (pp != NULL)
137 *pp = tp->lb;
138 return (0);
139 }
140 /*
141 * Adjust the line number for the number of lines used
142 * by the text input buffers.
143 */
144 if (lno > l2)
145 lno -= l2 - l1;
146 }
147
148 /* Look-aside into the cache, and see if the line we want is there. */
149 if (lno == sp->c_lno) {
150 #if defined(DBDEBUG) && defined(TRACE)
151 vtrace("retrieve cached line %lu\n", (u_long)lno);
152 #endif
153 if (lenp != NULL)
154 *lenp = sp->c_len;
155 if (pp != NULL)
156 *pp = sp->c_lp;
157 return (0);
158 }
159 sp->c_lno = OOBLNO;
160
161 nocache:
162 nlen = 1024;
163 retry:
164 /* data.size contains length in bytes */
165 BINC_GOTO(sp, CHAR_T, sp->c_lp, sp->c_blen, nlen);
166
167 /* Get the line from the underlying database. */
168 key.data = &lno;
169 key.size = sizeof(lno);
170 switch (ep->db->get(ep->db, &key, &data, 0)) {
171 case -1:
172 goto err2;
173 case 1:
174 err1: if (LF_ISSET(DBG_FATAL))
175 err2: db_err(sp, lno);
176 alloc_err:
177 err3: if (lenp != NULL)
178 *lenp = 0;
179 if (pp != NULL)
180 *pp = NULL;
181 return (1);
182 case 0:
183 if (data.size > nlen) {
184 nlen = data.size;
185 goto retry;
186 } else
187 memcpy(sp->c_lp, data.data, nlen);
188 }
189
190 if (FILE2INT(sp, data.data, data.size, wp, wlen)) {
191 if (!F_ISSET(sp, SC_CONV_ERROR)) {
192 F_SET(sp, SC_CONV_ERROR);
193 msgq(sp, M_ERR, "324|Conversion error on line %d", lno);
194 }
195 goto err3;
196 }
197
198 /* Reset the cache. */
199 if (wp != data.data) {
200 BINC_GOTOW(sp, sp->c_lp, sp->c_blen, wlen);
201 MEMCPYW(sp->c_lp, wp, wlen);
202 }
203 sp->c_lno = lno;
204 sp->c_len = wlen;
205
206 #if defined(DBDEBUG) && defined(TRACE)
207 vtrace("retrieve DB line %lu\n", (u_long)lno);
208 #endif
209 if (lenp != NULL)
210 *lenp = wlen;
211 if (pp != NULL)
212 *pp = sp->c_lp;
213 return (0);
214 }
215
216 /*
217 * db_delete --
218 * Delete a line from the file.
219 *
220 * PUBLIC: int db_delete __P((SCR *, db_recno_t));
221 */
222 int
db_delete(SCR * sp,db_recno_t lno)223 db_delete(SCR *sp, db_recno_t lno)
224 {
225 DBT key;
226 EXF *ep;
227
228 #if defined(DBDEBUG) && defined(TRACE)
229 vtrace("delete line %lu\n", (u_long)lno);
230 #endif
231 /* Check for no underlying file. */
232 if ((ep = sp->ep) == NULL) {
233 ex_emsg(sp, NULL, EXM_NOFILEYET);
234 return (1);
235 }
236 if (ep->l_win && ep->l_win != sp->wp) {
237 ex_emsg(sp, NULL, EXM_LOCKED);
238 return 1;
239 }
240
241 /* Update marks, @ and global commands. */
242 if (mark_insdel(sp, LINE_DELETE, lno))
243 return (1);
244 if (ex_g_insdel(sp, LINE_DELETE, lno))
245 return (1);
246
247 /* Log change. */
248 log_line(sp, lno, LOG_LINE_DELETE_B);
249
250 /* Update file. */
251 key.data = &lno;
252 key.size = sizeof(lno);
253 sp->db_error = ep->db->del(ep->db, &key, 0);
254 if (sp->db_error != 0) {
255 if (sp->db_error == -1)
256 sp->db_error = errno;
257
258 msgq(sp, M_DBERR, "003|unable to delete line %lu",
259 (u_long)lno);
260 return (1);
261 }
262
263 /* Flush the cache, update line count, before screen update. */
264 update_cache(sp, LINE_DELETE, lno);
265
266 /* File now modified. */
267 if (F_ISSET(ep, F_FIRSTMODIFY))
268 (void)rcv_init(sp);
269 F_SET(ep, F_MODIFIED);
270
271 /* Log after change. */
272 log_line(sp, lno, LOG_LINE_DELETE_F);
273
274 /* Update screen. */
275 return (scr_update(sp, lno, LINE_DELETE, 1));
276 }
277
278 /*
279 * db_append --
280 * Append a line into the file.
281 *
282 * PUBLIC: int db_append __P((SCR *, int, db_recno_t, const CHAR_T *, size_t));
283 */
284 int
db_append(SCR * sp,int update,db_recno_t lno,const CHAR_T * p,size_t len)285 db_append(SCR *sp, int update, db_recno_t lno, const CHAR_T *p, size_t len)
286 {
287 DBT data, key;
288 EXF *ep;
289 const char *fp;
290 size_t flen;
291 int rval;
292
293 #if defined(DBDEBUG) && defined(TRACE)
294 vtrace("append to %lu: len %u {%.*s}\n", lno, len, MIN(len, 20), p);
295 #endif
296 /* Check for no underlying file. */
297 if ((ep = sp->ep) == NULL) {
298 ex_emsg(sp, NULL, EXM_NOFILEYET);
299 return (1);
300 }
301 if (ep->l_win && ep->l_win != sp->wp) {
302 ex_emsg(sp, NULL, EXM_LOCKED);
303 return 1;
304 }
305
306 /* Log before change. */
307 log_line(sp, lno + 1, LOG_LINE_APPEND_B);
308
309 INT2FILE(sp, p, len, fp, flen);
310
311 /* Update file. */
312 key.data = &lno;
313 key.size = sizeof(lno);
314 data.data = __UNCONST(fp);
315 data.size = flen;
316 if (ep->db->put(ep->db, &key, &data, R_IAFTER)) {
317 msgq(sp, M_DBERR, "004|unable to append to line %lu",
318 (u_long)lno);
319 return (1);
320 }
321
322 /* Flush the cache, update line count, before screen update. */
323 update_cache(sp, LINE_INSERT, lno);
324
325 /* File now dirty. */
326 if (F_ISSET(ep, F_FIRSTMODIFY))
327 (void)rcv_init(sp);
328 F_SET(ep, F_MODIFIED);
329
330 /* Log after change. */
331 log_line(sp, lno + 1, LOG_LINE_APPEND_F);
332
333 /* Update marks, @ and global commands. */
334 rval = 0;
335 if (mark_insdel(sp, LINE_INSERT, lno + 1))
336 rval = 1;
337 if (ex_g_insdel(sp, LINE_INSERT, lno + 1))
338 rval = 1;
339
340 /*
341 * Update screen.
342 *
343 * XXX
344 * Nasty hack. If multiple lines are input by the user, they aren't
345 * committed until an <ESC> is entered. The problem is the screen was
346 * updated/scrolled as each line was entered. So, when this routine
347 * is called to copy the new lines from the cut buffer into the file,
348 * it has to know not to update the screen again.
349 */
350 return (scr_update(sp, lno, LINE_APPEND, update) || rval);
351 }
352
353 /*
354 * db_insert --
355 * Insert a line into the file.
356 *
357 * PUBLIC: int db_insert __P((SCR *, db_recno_t, CHAR_T *, size_t));
358 */
359 int
db_insert(SCR * sp,db_recno_t lno,CHAR_T * p,size_t len)360 db_insert(SCR *sp, db_recno_t lno, CHAR_T *p, size_t len)
361 {
362 DBT data, key;
363 EXF *ep;
364 const char *fp;
365 size_t flen;
366 int rval;
367
368 #if defined(DBDEBUG) && defined(TRACE)
369 vtrace("insert before %lu: len %lu {%.*s}\n",
370 (u_long)lno, (u_long)len, MIN(len, 20), p);
371 #endif
372 /* Check for no underlying file. */
373 if ((ep = sp->ep) == NULL) {
374 ex_emsg(sp, NULL, EXM_NOFILEYET);
375 return (1);
376 }
377 if (ep->l_win && ep->l_win != sp->wp) {
378 ex_emsg(sp, NULL, EXM_LOCKED);
379 return 1;
380 }
381
382 /* Log before change. */
383 log_line(sp, lno, LOG_LINE_APPEND_B);
384
385 INT2FILE(sp, p, len, fp, flen);
386
387 /* Update file. */
388 key.data = &lno;
389 key.size = sizeof(lno);
390 data.data = __UNCONST(fp);
391 data.size = flen;
392 if (ep->db->put(ep->db, &key, &data, R_IBEFORE)) {
393 msgq(sp, M_SYSERR,
394 "005|unable to insert at line %lu", (u_long)lno);
395 return (1);
396 }
397
398 /* Flush the cache, update line count, before screen update. */
399 update_cache(sp, LINE_INSERT, lno);
400
401 /* File now dirty. */
402 if (F_ISSET(ep, F_FIRSTMODIFY))
403 (void)rcv_init(sp);
404 F_SET(ep, F_MODIFIED);
405
406 /* Log after change. */
407 log_line(sp, lno, LOG_LINE_APPEND_F);
408
409 /* Update marks, @ and global commands. */
410 rval = 0;
411 if (mark_insdel(sp, LINE_INSERT, lno))
412 rval = 1;
413 if (ex_g_insdel(sp, LINE_INSERT, lno))
414 rval = 1;
415
416 /* Update screen. */
417 return (scr_update(sp, lno, LINE_INSERT, 1) || rval);
418 }
419
420 /*
421 * db_set --
422 * Store a line in the file.
423 *
424 * PUBLIC: int db_set __P((SCR *, db_recno_t, CHAR_T *, size_t));
425 */
426 int
db_set(SCR * sp,db_recno_t lno,CHAR_T * p,size_t len)427 db_set(SCR *sp, db_recno_t lno, CHAR_T *p, size_t len)
428 {
429 DBT data, key;
430 EXF *ep;
431 const char *fp;
432 size_t flen;
433
434 #if defined(DBDEBUG) && defined(TRACE)
435 vtrace("replace line %lu: len %lu {%.*s}\n",
436 (u_long)lno, (u_long)len, MIN(len, 20), p);
437 #endif
438 /* Check for no underlying file. */
439 if ((ep = sp->ep) == NULL) {
440 ex_emsg(sp, NULL, EXM_NOFILEYET);
441 return (1);
442 }
443 if (ep->l_win && ep->l_win != sp->wp) {
444 ex_emsg(sp, NULL, EXM_LOCKED);
445 return 1;
446 }
447
448 /* Log before change. */
449 log_line(sp, lno, LOG_LINE_RESET_B);
450
451 INT2FILE(sp, p, len, fp, flen);
452
453 /* Update file. */
454 key.data = &lno;
455 key.size = sizeof(lno);
456 data.data = __UNCONST(fp);
457 data.size = flen;
458 sp->db_error =
459 ep->db->put(ep->db, &key, &data, 0);
460 if (sp->db_error != 0) {
461 if (sp->db_error == -1)
462 sp->db_error = errno;
463
464 msgq(sp, M_DBERR, "006|unable to store line %lu", (u_long)lno);
465 return (1);
466 }
467
468 /* Flush the cache, before logging or screen update. */
469 update_cache(sp, LINE_RESET, lno);
470
471 /* File now dirty. */
472 if (F_ISSET(ep, F_FIRSTMODIFY))
473 (void)rcv_init(sp);
474 F_SET(ep, F_MODIFIED);
475
476 /* Log after change. */
477 log_line(sp, lno, LOG_LINE_RESET_F);
478
479 /* Update screen. */
480 return (scr_update(sp, lno, LINE_RESET, 1));
481 }
482
483 /*
484 * db_exist --
485 * Return if a line exists.
486 *
487 * PUBLIC: int db_exist __P((SCR *, db_recno_t));
488 */
489 int
db_exist(SCR * sp,db_recno_t lno)490 db_exist(SCR *sp, db_recno_t lno)
491 {
492 EXF *ep;
493
494 /* Check for no underlying file. */
495 if ((ep = sp->ep) == NULL) {
496 ex_emsg(sp, NULL, EXM_NOFILEYET);
497 return (1);
498 }
499
500 if (lno == OOBLNO)
501 return (0);
502
503 /*
504 * Check the last-line number cache. Adjust the cached line
505 * number for the lines used by the text input buffers.
506 */
507 if (ep->c_nlines != OOBLNO)
508 return (lno <= (F_ISSET(sp, SC_TINPUT) ?
509 ep->c_nlines + (TAILQ_LAST(&sp->tiq, _texth)->lno -
510 TAILQ_FIRST(&sp->tiq)->lno) : ep->c_nlines));
511
512 /* Go get the line. */
513 return (!db_get(sp, lno, 0, NULL, NULL));
514 }
515
516 /*
517 * db_last --
518 * Return the number of lines in the file.
519 *
520 * PUBLIC: int db_last __P((SCR *, db_recno_t *));
521 */
522 int
db_last(SCR * sp,db_recno_t * lnop)523 db_last(SCR *sp, db_recno_t *lnop)
524 {
525 DBT data, key;
526 EXF *ep;
527 db_recno_t lno;
528 const CHAR_T *wp;
529 size_t wlen;
530
531 /* Check for no underlying file. */
532 if ((ep = sp->ep) == NULL) {
533 ex_emsg(sp, NULL, EXM_NOFILEYET);
534 return (1);
535 }
536
537 /*
538 * Check the last-line number cache. Adjust the cached line
539 * number for the lines used by the text input buffers.
540 */
541 if (ep->c_nlines != OOBLNO) {
542 *lnop = ep->c_nlines;
543 if (F_ISSET(sp, SC_TINPUT))
544 *lnop += TAILQ_LAST(&sp->tiq, _texth)->lno -
545 TAILQ_FIRST(&sp->tiq)->lno;
546 return (0);
547 }
548
549 key.data = &lno;
550 key.size = sizeof(lno);
551
552 sp->db_error = ep->db->seq(ep->db, &key, &data, R_LAST);
553 switch (sp->db_error) {
554 case 1:
555 *lnop = 0;
556 return (0);
557 case -1:
558 sp->db_error = errno;
559 alloc_err:
560 msgq(sp, M_DBERR, "007|unable to get last line");
561 *lnop = 0;
562 return (1);
563 case 0:
564 ;
565 }
566
567 memcpy(&lno, key.data, sizeof(lno));
568
569 if (lno != sp->c_lno) {
570 FILE2INT(sp, data.data, data.size, wp, wlen);
571
572 /* Fill the cache. */
573 BINC_GOTOW(sp, sp->c_lp, sp->c_blen, wlen);
574 MEMCPYW(sp->c_lp, wp, wlen);
575 sp->c_lno = lno;
576 sp->c_len = wlen;
577 }
578 ep->c_nlines = lno;
579
580 /* Return the value. */
581 *lnop = (F_ISSET(sp, SC_TINPUT) &&
582 TAILQ_LAST(&sp->tiq, _texth)->lno > lno ?
583 TAILQ_LAST(&sp->tiq, _texth)->lno : lno);
584 return (0);
585 }
586
587 /*
588 * db_err --
589 * Report a line error.
590 *
591 * PUBLIC: void db_err __P((SCR *, db_recno_t));
592 */
593 void
db_err(SCR * sp,db_recno_t lno)594 db_err(SCR *sp, db_recno_t lno)
595 {
596 msgq(sp, M_ERR,
597 "008|Error: unable to retrieve line %lu", (u_long)lno);
598 }
599
600 /*
601 * scr_update --
602 * Update all of the screens that are backed by the file that
603 * just changed.
604 * PUBLIC: int scr_update __P((SCR *sp, db_recno_t lno,
605 * PUBLIC: lnop_t op, int current));
606 */
607 int
scr_update(SCR * sp,db_recno_t lno,lnop_t op,int current)608 scr_update(SCR *sp, db_recno_t lno, lnop_t op, int current)
609 {
610 EXF *ep;
611 SCR *tsp;
612 WIN *wp;
613
614 if (F_ISSET(sp, SC_EX))
615 return (0);
616
617 /* XXXX goes outside of window */
618 ep = sp->ep;
619 if (ep->refcnt != 1)
620 TAILQ_FOREACH(wp, &sp->gp->dq, q)
621 TAILQ_FOREACH(tsp, &wp->scrq, q)
622 if (sp != tsp && tsp->ep == ep)
623 if (vs_change(tsp, lno, op))
624 return (1);
625 return (current ? vs_change(sp, lno, op) : 0);
626 }
627
628 /*
629 * PUBLIC: void update_cache __P((SCR *sp, lnop_t op, db_recno_t lno));
630 */
631 void
update_cache(SCR * sp,lnop_t op,db_recno_t lno)632 update_cache(SCR *sp, lnop_t op, db_recno_t lno)
633 {
634 SCR* scrp;
635 EXF *ep;
636
637 ep = sp->ep;
638
639 /* Flush the cache, update line count, before screen update. */
640 /* The flushing is probably not needed, since it was incorrect
641 * for db_insert. It might be better to adjust it, like
642 * marks, @ and global
643 */
644 TAILQ_FOREACH(scrp, &ep->scrq, eq)
645 switch (op) {
646 case LINE_INSERT:
647 case LINE_DELETE:
648 if (lno <= scrp->c_lno)
649 scrp->c_lno = OOBLNO;
650 break;
651 case LINE_RESET:
652 if (lno == scrp->c_lno)
653 scrp->c_lno = OOBLNO;
654 break;
655 case LINE_APPEND:
656 break;
657 }
658
659 if (ep->c_nlines != OOBLNO)
660 switch (op) {
661 case LINE_INSERT:
662 ++ep->c_nlines;
663 break;
664 case LINE_DELETE:
665 --ep->c_nlines;
666 break;
667 case LINE_APPEND:
668 case LINE_RESET:
669 break;
670 }
671 }
672
673 /*
674 * PUBLIC: int db_msg_open __P((SCR *, const char *, DB **));
675 */
db_msg_open(SCR * sp,const char * file,DB ** dbp)676 int db_msg_open(SCR *sp, const char *file, DB **dbp)
677 {
678 *dbp = dbopen(file, O_NONBLOCK | O_RDONLY, 0, DB_RECNO, NULL);
679
680 return *dbp == NULL;
681 }
682
683 /*
684 * PUBLIC: int db_init __P((SCR *, EXF *, char *, char *, size_t, int *));
685 */
686 int
db_init(SCR * sp,EXF * ep,char * rcv_name,char * oname,size_t psize,int * open_err)687 db_init(SCR *sp, EXF *ep, char *rcv_name, char *oname, size_t psize, int *open_err)
688 {
689 RECNOINFO oinfo;
690
691 memset(&oinfo, 0, sizeof(RECNOINFO));
692 oinfo.bval = '\n'; /* Always set. */
693 /*
694 * If we are not recovering, set the pagesize and arrange to
695 * first get a snapshot of the file.
696 */
697 if (rcv_name == NULL) {
698 oinfo.psize = psize;
699 oinfo.flags = R_SNAPSHOT;
700 }
701 /*
702 * Always set the btree name, otherwise we are going to be using
703 * an in-memory database for the btree.
704 */
705 oinfo.bfname = ep->rcv_path;
706
707 #define _DB_OPEN_MODE S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH
708
709 ep->db = dbopen(rcv_name == NULL ? oname : NULL,
710 O_NONBLOCK | O_RDONLY, _DB_OPEN_MODE, DB_RECNO, &oinfo);
711
712 if (!ep->db) {
713 msgq_str(sp,
714 M_DBERR, rcv_name == NULL ? oname : rcv_name, "%s");
715 /*
716 * !!!
717 * Historically, vi permitted users to edit files that couldn't
718 * be read. This isn't useful for single files from a command
719 * line, but it's quite useful for "vi *.c", since you can skip
720 * past files that you can't read.
721 */
722 ep->db = NULL; /* Don't close it; it wasn't opened */
723
724 *open_err = 1;
725 return 1;
726 } else {
727 /*
728 * We always sync the underlying btree so that the header
729 * is written first
730 */
731 ep->db->sync(ep->db, R_RECNOSYNC);
732 }
733
734 return 0;
735 }
736
737 const char *
db_strerror(int error)738 db_strerror(int error)
739 {
740 return error > 0 ? strerror(error) : "record not found";
741 }
742