Mercurial > cpython-lru_cache-weakref

comparison Modules/bsddbmodule.c @ 16798:258dcafe2d0b legacy-trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Gustavo Niemeyer <niemeyer@conectiva.com>: Fixed recno support (keys are integers rather than strings). Work around DB bug that cause stdin to be closed by rnopen() when the DB file needed to exist but did not (no longer segfaults). This closes SF tracker patch #403445. Also wrapped some long lines and added whitespace around operators -- FLD.
author Fred Drake <fdrake@acm.org>
date Tue, 27 Feb 2001 18:56:46 +0000
parents 564927c55742
children 848f08559916
comparison
equal deleted inserted replaced
16797:3c2142f076b4 16798:258dcafe2d0b
1 /* Berkeley DB interface. 1 /* Berkeley DB interface.
2 Author: Michael McLay 2 Author: Michael McLay
3 Hacked: Guido van Rossum 3 Hacked: Guido van Rossum
4 Btree and Recno additions plus sequence methods: David Ely 4 Btree and Recno additions plus sequence methods: David Ely
5 Hacked by Gustavo Niemeyer <niemeyer@conectiva.com> fixing recno
6 support.
5 7
6 XXX To do: 8 XXX To do:
7 - provide interface to the B-tree and record libraries too
8 - provide a way to access the various hash functions 9 - provide a way to access the various hash functions
9 - support more open flags 10 - support more open flags
10 11
11 The windows port of the Berkeley DB code is hard to find on the web: 12 The windows port of the Berkeley DB code is hard to find on the web:
12 www.nightmare.com/software.html 13 www.nightmare.com/software.html
13 */ 14 */
14 15
15 #include "Python.h" 16 #include "Python.h"
16 #ifdef WITH_THREAD 17 #ifdef WITH_THREAD
17 #include "pythread.h" 18 #include "pythread.h"
19 #endif
20
21 #ifdef HAVE_UNISTD_H
22 #include <unistd.h>
18 #endif 23 #endif
19 24
20 #include <sys/types.h> 25 #include <sys/types.h>
21 #include <sys/stat.h> 26 #include <sys/stat.h>
22 #include <fcntl.h> 27 #include <fcntl.h>
30 35
31 typedef struct { 36 typedef struct {
32 PyObject_HEAD 37 PyObject_HEAD
33 DB *di_bsddb; 38 DB *di_bsddb;
34 int di_size; /* -1 means recompute */ 39 int di_size; /* -1 means recompute */
40 int di_type;
35 #ifdef WITH_THREAD 41 #ifdef WITH_THREAD
36 PyThread_type_lock di_lock; 42 PyThread_type_lock di_lock;
37 #endif 43 #endif
38 } bsddbobject; 44 } bsddbobject;
39 45
40 staticforward PyTypeObject Bsddbtype; 46 staticforward PyTypeObject Bsddbtype;
41 47
42 #define is_bsddbobject(v) ((v)->ob_type == &Bsddbtype) 48 #define is_bsddbobject(v) ((v)->ob_type == &Bsddbtype)
43 #define check_bsddbobject_open(v) if ((v)->di_bsddb == NULL) \ 49 #define check_bsddbobject_open(v, r) if ((v)->di_bsddb == NULL) \
44 { PyErr_SetString(BsddbError, \ 50 { PyErr_SetString(BsddbError, \
45 "BSDDB object has already been closed"); \ 51 "BSDDB object has already been closed"); \
46 return NULL; } 52 return r; }
47 53
48 static PyObject *BsddbError; 54 static PyObject *BsddbError;
49 55
50 static PyObject * 56 static PyObject *
51 newdbhashobject(char *file, int flags, int mode, 57 newdbhashobject(char *file, int flags, int mode,
79 Py_DECREF(dp); 85 Py_DECREF(dp);
80 return NULL; 86 return NULL;
81 } 87 }
82 88
83 dp->di_size = -1; 89 dp->di_size = -1;
90 dp->di_type = DB_HASH;
91
84 #ifdef WITH_THREAD 92 #ifdef WITH_THREAD
85 dp->di_lock = PyThread_allocate_lock(); 93 dp->di_lock = PyThread_allocate_lock();
86 if (dp->di_lock == NULL) { 94 if (dp->di_lock == NULL) {
87 PyErr_SetString(BsddbError, "can't allocate lock"); 95 PyErr_SetString(BsddbError, "can't allocate lock");
88 Py_DECREF(dp); 96 Py_DECREF(dp);
127 Py_DECREF(dp); 135 Py_DECREF(dp);
128 return NULL; 136 return NULL;
129 } 137 }
130 138
131 dp->di_size = -1; 139 dp->di_size = -1;
140 dp->di_type = DB_BTREE;
141
132 #ifdef WITH_THREAD 142 #ifdef WITH_THREAD
133 dp->di_lock = PyThread_allocate_lock(); 143 dp->di_lock = PyThread_allocate_lock();
134 if (dp->di_lock == NULL) { 144 if (dp->di_lock == NULL) {
135 PyErr_SetString(BsddbError, "can't allocate lock"); 145 PyErr_SetString(BsddbError, "can't allocate lock");
136 Py_DECREF(dp); 146 Py_DECREF(dp);
146 int rnflags, int cachesize, int psize, int lorder, 156 int rnflags, int cachesize, int psize, int lorder,
147 size_t reclen, u_char bval, char *bfname) 157 size_t reclen, u_char bval, char *bfname)
148 { 158 {
149 bsddbobject *dp; 159 bsddbobject *dp;
150 RECNOINFO info; 160 RECNOINFO info;
161 int fd;
151 162
152 if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL) 163 if ((dp = PyObject_New(bsddbobject, &Bsddbtype)) == NULL)
153 return NULL; 164 return NULL;
154 165
155 info.flags = rnflags; 166 info.flags = rnflags;
161 info.bfname = bfname; 172 info.bfname = bfname;
162 173
163 #ifdef O_BINARY 174 #ifdef O_BINARY
164 flags |= O_BINARY; 175 flags |= O_BINARY;
165 #endif 176 #endif
166 Py_BEGIN_ALLOW_THREADS 177 /* This is a hack to avoid a dbopen() bug that happens when
167 dp->di_bsddb = dbopen(file, flags, mode, DB_RECNO, &info); 178 * it fails. */
168 Py_END_ALLOW_THREADS 179 fd = open(file, flags);
180 if (fd == -1) {
181 dp->di_bsddb = NULL;
182 }
183 else {
184 close(fd);
185 Py_BEGIN_ALLOW_THREADS
186 dp->di_bsddb = dbopen(file, flags, mode, DB_RECNO, &info);
187 Py_END_ALLOW_THREADS
188 }
169 if (dp->di_bsddb == NULL) { 189 if (dp->di_bsddb == NULL) {
170 PyErr_SetFromErrno(BsddbError); 190 PyErr_SetFromErrno(BsddbError);
171 #ifdef WITH_THREAD 191 #ifdef WITH_THREAD
172 dp->di_lock = NULL; 192 dp->di_lock = NULL;
173 #endif 193 #endif
174 Py_DECREF(dp); 194 Py_DECREF(dp);
175 return NULL; 195 return NULL;
176 } 196 }
177 197
178 dp->di_size = -1; 198 dp->di_size = -1;
199 dp->di_type = DB_RECNO;
200
179 #ifdef WITH_THREAD 201 #ifdef WITH_THREAD
180 dp->di_lock = PyThread_allocate_lock(); 202 dp->di_lock = PyThread_allocate_lock();
181 if (dp->di_lock == NULL) { 203 if (dp->di_lock == NULL) {
182 PyErr_SetString(BsddbError, "can't allocate lock"); 204 PyErr_SetString(BsddbError, "can't allocate lock");
183 Py_DECREF(dp); 205 Py_DECREF(dp);
223 #endif 245 #endif
224 246
225 static int 247 static int
226 bsddb_length(bsddbobject *dp) 248 bsddb_length(bsddbobject *dp)
227 { 249 {
228 if (dp->di_bsddb == NULL) { 250 check_bsddbobject_open(dp, -1);
229 PyErr_SetString(BsddbError,
230 "BSDDB object has already been closed");
231 return -1;
232 }
233 if (dp->di_size < 0) { 251 if (dp->di_size < 0) {
234 DBT krec, drec; 252 DBT krec, drec;
235 int status; 253 int status;
236 int size = 0; 254 int size = 0;
237 BSDDB_BGN_SAVE(dp) 255 BSDDB_BGN_SAVE(dp)
257 int status; 275 int status;
258 DBT krec, drec; 276 DBT krec, drec;
259 char *data,buf[4096]; 277 char *data,buf[4096];
260 int size; 278 int size;
261 PyObject *result; 279 PyObject *result;
262 280 recno_t recno;
263 if (!PyArg_Parse(key, "s#", &data, &size))
264 return NULL;
265 check_bsddbobject_open(dp);
266 281
267 krec.data = data; 282 if (dp->di_type == DB_RECNO) {
268 krec.size = size; 283 if (!PyArg_Parse(key, "i", &recno)) {
284 PyErr_SetString(PyExc_TypeError,
285 "key type must be integer");
286 return NULL;
287 }
288 krec.data = &recno;
289 krec.size = sizeof(recno);
290 }
291 else {
292 if (!PyArg_Parse(key, "s#", &data, &size)) {
293 PyErr_SetString(PyExc_TypeError,
294 "key type must be string");
295 return NULL;
296 }
297 krec.data = data;
298 krec.size = size;
299 }
300 check_bsddbobject_open(dp, NULL);
269 301
270 BSDDB_BGN_SAVE(dp) 302 BSDDB_BGN_SAVE(dp)
271 status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0); 303 status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
272 if (status == 0) { 304 if (status == 0) {
273 if (drec.size > sizeof(buf)) data = malloc(drec.size); 305 if (drec.size > sizeof(buf)) data = malloc(drec.size);
294 { 326 {
295 int status; 327 int status;
296 DBT krec, drec; 328 DBT krec, drec;
297 char *data; 329 char *data;
298 int size; 330 int size;
299 331 recno_t recno;
300 if (!PyArg_Parse(key, "s#", &data, &size)) { 332
301 PyErr_SetString(PyExc_TypeError, 333 if (dp->di_type == DB_RECNO) {
302 "bsddb key type must be string"); 334 if (!PyArg_Parse(key, "i", &recno)) {
303 return -1; 335 PyErr_SetString(PyExc_TypeError,
304 } 336 "bsddb key type must be integer");
305 if (dp->di_bsddb == NULL) { 337 return -1;
306 PyErr_SetString(BsddbError, 338 }
307 "BSDDB object has already been closed"); 339 krec.data = &recno;
308 return -1; 340 krec.size = sizeof(recno);
309 } 341 }
310 krec.data = data; 342 else {
311 krec.size = size; 343 if (!PyArg_Parse(key, "s#", &data, &size)) {
344 PyErr_SetString(PyExc_TypeError,
345 "bsddb key type must be string");
346 return -1;
347 }
348 krec.data = data;
349 krec.size = size;
350 }
351 check_bsddbobject_open(dp, -1);
312 dp->di_size = -1; 352 dp->di_size = -1;
313 if (value == NULL) { 353 if (value == NULL) {
314 BSDDB_BGN_SAVE(dp) 354 BSDDB_BGN_SAVE(dp)
315 status = (dp->di_bsddb->del)(dp->di_bsddb, &krec, 0); 355 status = (dp->di_bsddb->del)(dp->di_bsddb, &krec, 0);
316 BSDDB_END_SAVE(dp) 356 BSDDB_END_SAVE(dp)
321 "bsddb value type must be string"); 361 "bsddb value type must be string");
322 return -1; 362 return -1;
323 } 363 }
324 drec.data = data; 364 drec.data = data;
325 drec.size = size; 365 drec.size = size;
326 #if 0
327 /* For RECNO, put fails with 'No space left on device'
328 after a few short records are added?? Looks fine
329 to this point... linked with 1.85 on Solaris Intel
330 Roger E. Masse 1/16/97
331 */
332 printf("before put data: '%s', size: %d\n",
333 drec.data, drec.size);
334 printf("before put key= '%s', size= %d\n",
335 krec.data, krec.size);
336 #endif
337 BSDDB_BGN_SAVE(dp) 366 BSDDB_BGN_SAVE(dp)
338 status = (dp->di_bsddb->put)(dp->di_bsddb, &krec, &drec, 0); 367 status = (dp->di_bsddb->put)(dp->di_bsddb, &krec, &drec, 0);
339 BSDDB_END_SAVE(dp) 368 BSDDB_END_SAVE(dp)
340 } 369 }
341 if (status != 0) { 370 if (status != 0) {
376 } 405 }
377 406
378 static PyObject * 407 static PyObject *
379 bsddb_keys(bsddbobject *dp, PyObject *args) 408 bsddb_keys(bsddbobject *dp, PyObject *args)
380 { 409 {
381 PyObject *list, *item; 410 PyObject *list, *item=NULL;
382 DBT krec, drec; 411 DBT krec, drec;
383 char *data=NULL,buf[4096]; 412 char *data=NULL,buf[4096];
384 int status; 413 int status;
385 int err; 414 int err;
386 415
387 if (!PyArg_NoArgs(args)) 416 if (!PyArg_NoArgs(args))
388 return NULL; 417 return NULL;
389 check_bsddbobject_open(dp); 418 check_bsddbobject_open(dp, NULL);
390 list = PyList_New(0); 419 list = PyList_New(0);
391 if (list == NULL) 420 if (list == NULL)
392 return NULL; 421 return NULL;
393 BSDDB_BGN_SAVE(dp) 422 BSDDB_BGN_SAVE(dp)
394 status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_FIRST); 423 status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_FIRST);
395 if (status == 0) { 424 if (status == 0) {
396 if (krec.size > sizeof(buf)) data = malloc(krec.size); 425 if (krec.size > sizeof(buf)) data = malloc(krec.size);
397 else data = buf; 426 else data = buf;
398 if (data!=NULL) memcpy(data,krec.data,krec.size); 427 if (data != NULL) memcpy(data,krec.data,krec.size);
399 } 428 }
400 BSDDB_END_SAVE(dp) 429 BSDDB_END_SAVE(dp)
401 if (data==NULL) return PyErr_NoMemory(); 430 if (data==NULL) return PyErr_NoMemory();
402 while (status == 0) { 431 while (status == 0) {
403 item = PyString_FromStringAndSize(data, (int)krec.size); 432 if (dp->di_type == DB_RECNO)
433 item = PyInt_FromLong(*((int*)data));
434 else
435 item = PyString_FromStringAndSize(data,
436 (int)krec.size);
404 if (data != buf) free(data); 437 if (data != buf) free(data);
405 if (item == NULL) { 438 if (item == NULL) {
406 Py_DECREF(list); 439 Py_DECREF(list);
407 return NULL; 440 return NULL;
408 } 441 }
440 { 473 {
441 DBT krec, drec; 474 DBT krec, drec;
442 int status; 475 int status;
443 char *data; 476 char *data;
444 int size; 477 int size;
445 478 recno_t recno;
446 if (!PyArg_Parse(args, "s#", &data, &size)) 479
447 return NULL; 480 if (dp->di_type == DB_RECNO) {
448 check_bsddbobject_open(dp); 481 if (!PyArg_Parse(args, "i", &recno)) {
449 krec.data = data; 482 PyErr_SetString(PyExc_TypeError,
450 krec.size = size; 483 "key type must be integer");
484 return NULL;
485 }
486 krec.data = &recno;
487 krec.size = sizeof(recno);
488 }
489 else {
490 if (!PyArg_Parse(args, "s#", &data, &size)) {
491 PyErr_SetString(PyExc_TypeError,
492 "key type must be string");
493 return NULL;
494 }
495 krec.data = data;
496 krec.size = size;
497 }
498 check_bsddbobject_open(dp, NULL);
451 499
452 BSDDB_BGN_SAVE(dp) 500 BSDDB_BGN_SAVE(dp)
453 status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0); 501 status = (dp->di_bsddb->get)(dp->di_bsddb, &krec, &drec, 0);
454 BSDDB_END_SAVE(dp) 502 BSDDB_END_SAVE(dp)
455 if (status < 0) { 503 if (status < 0) {
466 int status; 514 int status;
467 DBT krec, drec; 515 DBT krec, drec;
468 char *data,buf[4096]; 516 char *data,buf[4096];
469 int size; 517 int size;
470 PyObject *result; 518 PyObject *result;
471 519 recno_t recno;
472 if (!PyArg_Parse(key, "s#", &data, &size)) 520
473 return NULL; 521 if (dp->di_type == DB_RECNO) {
474 check_bsddbobject_open(dp); 522 if (!PyArg_Parse(key, "i", &recno)) {
475 krec.data = data; 523 PyErr_SetString(PyExc_TypeError,
476 krec.size = size; 524 "key type must be integer");
525 return NULL;
526 }
527 krec.data = &recno;
528 krec.size = sizeof(recno);
529 }
530 else {
531 if (!PyArg_Parse(key, "s#", &data, &size)) {
532 PyErr_SetString(PyExc_TypeError,
533 "key type must be string");
534 return NULL;
535 }
536 krec.data = data;
537 krec.size = size;
538 }
539 check_bsddbobject_open(dp, NULL);
477 540
478 BSDDB_BGN_SAVE(dp) 541 BSDDB_BGN_SAVE(dp)
479 status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_CURSOR); 542 status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, &drec, R_CURSOR);
480 if (status == 0) { 543 if (status == 0) {
481 if (drec.size > sizeof(buf)) data = malloc(drec.size); 544 if (drec.size > sizeof(buf)) data = malloc(drec.size);
490 else 553 else
491 PyErr_SetObject(PyExc_KeyError, key); 554 PyErr_SetObject(PyExc_KeyError, key);
492 return NULL; 555 return NULL;
493 } 556 }
494 557
495 result = Py_BuildValue("s#s#", krec.data, krec.size, data, drec.size); 558 if (dp->di_type == DB_RECNO)
559 result = Py_BuildValue("is#", *((int*)krec.data),
560 data, drec.size);
561 else
562 result = Py_BuildValue("s#s#", krec.data, krec.size,
563 data, drec.size);
496 if (data != buf) free(data); 564 if (data != buf) free(data);
497 return result; 565 return result;
498 } 566 }
499 567
500 static PyObject * 568 static PyObject *
507 PyObject *result; 575 PyObject *result;
508 576
509 if (!PyArg_NoArgs(args)) 577 if (!PyArg_NoArgs(args))
510 return NULL; 578 return NULL;
511 579
512 check_bsddbobject_open(dp); 580 check_bsddbobject_open(dp, NULL);
513 krec.data = 0; 581 krec.data = 0;
514 krec.size = 0; 582 krec.size = 0;
515 583
516 BSDDB_BGN_SAVE(dp) 584 BSDDB_BGN_SAVE(dp)
517 status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec, 585 status = (dp->di_bsddb->seq)(dp->di_bsddb, &krec,
518 &drec, sequence_request); 586 &drec, sequence_request);
519 if (status == 0) { 587 if (status == 0) {
520 if (krec.size > sizeof(kbuf)) kdata = malloc(krec.size); 588 if (krec.size > sizeof(kbuf)) kdata = malloc(krec.size);
521 else kdata = kbuf; 589 else kdata = kbuf;
522 if (kdata!=NULL) memcpy(kdata,krec.data,krec.size); 590 if (kdata != NULL) memcpy(kdata,krec.data,krec.size);
523 if (drec.size > sizeof(dbuf)) ddata = malloc(drec.size); 591 if (drec.size > sizeof(dbuf)) ddata = malloc(drec.size);
524 else ddata = dbuf; 592 else ddata = dbuf;
525 if (ddata!=NULL) memcpy(ddata,drec.data,drec.size); 593 if (ddata != NULL) memcpy(ddata,drec.data,drec.size);
526 } 594 }
527 BSDDB_END_SAVE(dp) 595 BSDDB_END_SAVE(dp)
528 if (status == 0) { 596 if (status == 0) {
529 if ((kdata==NULL) || (ddata==NULL)) 597 if ((kdata == NULL) || (ddata == NULL))
530 return PyErr_NoMemory(); 598 return PyErr_NoMemory();
531 } 599 }
532 else { 600 else {
533 /* (status != 0) */ 601 /* (status != 0) */
534 if (status < 0) 602 if (status < 0)
536 else 604 else
537 PyErr_SetObject(PyExc_KeyError, args); 605 PyErr_SetObject(PyExc_KeyError, args);
538 return NULL; 606 return NULL;
539 } 607 }
540 608
541 result = Py_BuildValue("s#s#", kdata, krec.size, ddata, drec.size); 609
610 if (dp->di_type == DB_RECNO)
611 result = Py_BuildValue("is#", *((int*)kdata),
612 ddata, drec.size);
613 else
614 result = Py_BuildValue("s#s#", kdata, krec.size,
615 ddata, drec.size);
542 if (kdata != kbuf) free(kdata); 616 if (kdata != kbuf) free(kdata);
543 if (ddata != dbuf) free(ddata); 617 if (ddata != dbuf) free(ddata);
544 return result; 618 return result;
545 } 619 }
546 620
569 { 643 {
570 int status; 644 int status;
571 645
572 if (!PyArg_NoArgs(args)) 646 if (!PyArg_NoArgs(args))
573 return NULL; 647 return NULL;
574 check_bsddbobject_open(dp); 648 check_bsddbobject_open(dp, NULL);
575 BSDDB_BGN_SAVE(dp) 649 BSDDB_BGN_SAVE(dp)
576 status = (dp->di_bsddb->sync)(dp->di_bsddb, 0); 650 status = (dp->di_bsddb->sync)(dp->di_bsddb, 0);
577 BSDDB_END_SAVE(dp) 651 BSDDB_END_SAVE(dp)
578 if (status != 0) { 652 if (status != 0) {
579 PyErr_SetFromErrno(BsddbError); 653 PyErr_SetFromErrno(BsddbError);
739 &file, &flag, &mode, 813 &file, &flag, &mode,
740 &rnflags, &cachesize, &psize, &lorder, 814 &rnflags, &cachesize, &psize, &lorder,
741 &reclen, &bval, &bfname)) 815 &reclen, &bval, &bfname))
742 return NULL; 816 return NULL;
743 817
744 # if 0
745 printf("file: %s\n", file);
746 printf("flag: %s\n", flag);
747 printf("mode: %d\n", mode);
748 printf("rnflags: 0x%x\n", rnflags);
749 printf("cachesize: %d\n", cachesize);
750 printf("psize: %d\n", psize);
751 printf("lorder: %d\n", 0);
752 printf("reclen: %d\n", reclen);
753 printf("bval: %c\n", bval[0]);
754 printf("bfname %s\n", bfname);
755 #endif
756
757 if (flag != NULL) { 818 if (flag != NULL) {
758 /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */ 819 /* XXX need to pass O_EXCL, O_EXLOCK, O_NONBLOCK, O_SHLOCK */
759 if (flag[0] == 'r') 820 if (flag[0] == 'r')
760 flags = O_RDONLY; 821 flags = O_RDONLY;
761 else if (flag[0] == 'w') 822 else if (flag[0] == 'w')