Modules/gdbmmodule.c

   1
   2 /* DBM module using dictionary interface */
   3 /* Author: Anthony Baxter, after dbmmodule.c */
   4 /* Doc strings: Mitch Chapman */
   5
   6
   7 #include "Python.h"
   8
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <fcntl.h>
  12 #include "gdbm.h"
  13
  14 #if defined(WIN32) && !defined(__CYGWIN__)
  15 #include "gdbmerrno.h"
  16 extern const char * gdbm_strerror(gdbm_error);
  17 #endif
  18
  19 PyDoc_STRVAR(gdbmmodule__doc__,
  20 "This module provides an interface to the GNU DBM (GDBM) library.\n\
  21 \n\
  22 This module is quite similar to the dbm module, but uses GDBM instead to\n\
  23 provide some additional functionality. Please note that the file formats\n\
  24 created by GDBM and dbm are incompatible. \n\
  25 \n\
  26 GDBM objects behave like mappings (dictionaries), except that keys and\n\
  27 values are always strings. Printing a GDBM object doesn't print the\n\
  28 keys and values, and the items() and values() methods are not\n\
  29 supported.");
  30
  31 typedef struct {
  32     PyObject_HEAD
  33     int di_size;        /* -1 means recompute */
  34     GDBM_FILE di_dbm;
  35 } dbmobject;
  36
  37 static PyTypeObject Dbmtype;
  38
  39 #define is_dbmobject(v) (Py_TYPE(v) == &Dbmtype)
  40 #define check_dbmobject_open(v) if ((v)->di_dbm == NULL) \
  41     { PyErr_SetString(DbmError, "GDBM object has already been closed"); \
  42       return NULL; }
  43
  44
  45
  46 static PyObject *DbmError;
  47
  48 PyDoc_STRVAR(gdbm_object__doc__,
  49 "This object represents a GDBM database.\n\
  50 GDBM objects behave like mappings (dictionaries), except that keys and\n\
  51 values are always strings. Printing a GDBM object doesn't print the\n\
  52 keys and values, and the items() and values() methods are not\n\
  53 supported.\n\
  54 \n\
  55 GDBM objects also support additional operations such as firstkey,\n\
  56 nextkey, reorganize, and sync.");
  57
  58 static PyObject *
  59 newdbmobject(char *file, int flags, int mode)
  60 {
  61     dbmobject *dp;
  62
  63     dp = PyObject_New(dbmobject, &Dbmtype);
  64     if (dp == NULL)
  65         return NULL;
  66     dp->di_size = -1;
  67     errno = 0;
  68     if ((dp->di_dbm = gdbm_open(file, 0, flags, mode, NULL)) == 0) {
  69         if (errno != 0)
  70             PyErr_SetFromErrno(DbmError);
  71         else
  72             PyErr_SetString(DbmError, gdbm_strerror(gdbm_errno));
  73         Py_DECREF(dp);
  74         return NULL;
  75     }
  76     return (PyObject *)dp;
  77 }
  78
  79 /* Methods */
  80
  81 static void
  82 dbm_dealloc(register dbmobject *dp)
  83 {
  84     if (dp->di_dbm)
  85         gdbm_close(dp->di_dbm);
  86     PyObject_Del(dp);
  87 }
  88
  89 static Py_ssize_t
  90 dbm_length(dbmobject *dp)
  91 {
  92     if (dp->di_dbm == NULL) {
  93         PyErr_SetString(DbmError, "GDBM object has already been closed");
  94         return -1;
  95     }
  96     if (dp->di_size < 0) {
  97         datum key,okey;
  98         int size;
  99         okey.dsize=0;
 100         okey.dptr=NULL;
 101
 102         size = 0;
 103         for (key=gdbm_firstkey(dp->di_dbm); key.dptr;
 104              key = gdbm_nextkey(dp->di_dbm,okey)) {
 105             size++;
 106             if(okey.dsize) free(okey.dptr);
 107             okey=key;
 108         }
 109         dp->di_size = size;
 110     }
 111     return dp->di_size;
 112 }
 113
 114 static PyObject *
 115 dbm_subscript(dbmobject *dp, register PyObject *key)
 116 {
 117     PyObject *v;
 118     datum drec, krec;
 119
 120     if (!PyArg_Parse(key, "s#", &krec.dptr, &krec.dsize) )
 121         return NULL;
 122
 123     if (dp->di_dbm == NULL) {
 124         PyErr_SetString(DbmError,
 125                         "GDBM object has already been closed");
 126         return NULL;
 127     }
 128     drec = gdbm_fetch(dp->di_dbm, krec);
 129     if (drec.dptr == 0) {
 130         PyErr_SetString(PyExc_KeyError,
 131                         PyString_AS_STRING((PyStringObject *)key));
 132         return NULL;
 133     }
 134     v = PyString_FromStringAndSize(drec.dptr, drec.dsize);
 135     free(drec.dptr);
 136     return v;
 137 }
 138
 139 static int
 140 dbm_ass_sub(dbmobject *dp, PyObject *v, PyObject *w)
 141 {
 142     datum krec, drec;
 143
 144     if (!PyArg_Parse(v, "s#", &krec.dptr, &krec.dsize) ) {
 145         PyErr_SetString(PyExc_TypeError,
 146                         "gdbm mappings have string indices only");
 147         return -1;
 148     }
 149     if (dp->di_dbm == NULL) {
 150         PyErr_SetString(DbmError,
 151                         "GDBM object has already been closed");
 152         return -1;
 153     }
 154     dp->di_size = -1;
 155     if (w == NULL) {
 156         if (gdbm_delete(dp->di_dbm, krec) < 0) {
 157             PyErr_SetString(PyExc_KeyError,
 158                             PyString_AS_STRING((PyStringObject *)v));
 159             return -1;
 160         }
 161     }
 162     else {
 163         if (!PyArg_Parse(w, "s#", &drec.dptr, &drec.dsize)) {
 164             PyErr_SetString(PyExc_TypeError,
 165                             "gdbm mappings have string elements only");
 166             return -1;
 167         }
 168         errno = 0;
 169         if (gdbm_store(dp->di_dbm, krec, drec, GDBM_REPLACE) < 0) {
 170             if (errno != 0)
 171                 PyErr_SetFromErrno(DbmError);
 172             else
 173                 PyErr_SetString(DbmError,
 174                                 gdbm_strerror(gdbm_errno));
 175             return -1;
 176         }
 177     }
 178     return 0;
 179 }
 180
 181 static int
 182 dbm_contains(register dbmobject *dp, PyObject *arg)
 183 {
 184     datum key;
 185
 186     if ((dp)->di_dbm == NULL) {
 187         PyErr_SetString(DbmError,
 188                         "GDBM object has already been closed");
 189         return -1;
 190     }
 191     if (!PyString_Check(arg)) {
 192         PyErr_Format(PyExc_TypeError,
 193                      "gdbm key must be string, not %.100s",
 194                      arg->ob_type->tp_name);
 195         return -1;
 196     }
 197     key.dptr = PyString_AS_STRING(arg);
 198     key.dsize = PyString_GET_SIZE(arg);
 199     return gdbm_exists(dp->di_dbm, key);
 200 }
 201
 202 static PySequenceMethods dbm_as_sequence = {
 203     (lenfunc)dbm_length,               /*_length*/
 204        0,              /*sq_concat*/
 205        0,                      /*sq_repeat*/
 206        0,                      /*sq_item*/
 207        0,                      /*sq_slice*/
 208        0,                      /*sq_ass_item*/
 209        0,                  /*sq_ass_slice*/
 210        (objobjproc)dbm_contains,               /*sq_contains*/
 211        0,                  /*sq_inplace_concat*/
 212        0                   /*sq_inplace_repeat*/
 213 };
 214
 215 static PyMappingMethods dbm_as_mapping = {
 216     (lenfunc)dbm_length,                /*mp_length*/
 217     (binaryfunc)dbm_subscript,          /*mp_subscript*/
 218     (objobjargproc)dbm_ass_sub,         /*mp_ass_subscript*/
 219 };
 220
 221 PyDoc_STRVAR(dbm_close__doc__,
 222 "close() -> None\n\
 223 Closes the database.");
 224
 225 static PyObject *
 226 dbm_close(register dbmobject *dp, PyObject *unused)
 227 {
 228     if (dp->di_dbm)
 229         gdbm_close(dp->di_dbm);
 230     dp->di_dbm = NULL;
 231     Py_INCREF(Py_None);
 232     return Py_None;
 233 }
 234
 235 PyDoc_STRVAR(dbm_keys__doc__,
 236 "keys() -> list_of_keys\n\
 237 Get a list of all keys in the database.");
 238
 239 static PyObject *
 240 dbm_keys(register dbmobject *dp, PyObject *unused)
 241 {
 242     register PyObject *v, *item;
 243     datum key, nextkey;
 244     int err;
 245
 246     if (dp == NULL || !is_dbmobject(dp)) {
 247         PyErr_BadInternalCall();
 248         return NULL;
 249     }
 250     check_dbmobject_open(dp);
 251
 252     v = PyList_New(0);
 253     if (v == NULL)
 254         return NULL;
 255
 256     key = gdbm_firstkey(dp->di_dbm);
 257     while (key.dptr) {
 258         item = PyString_FromStringAndSize(key.dptr, key.dsize);
 259         if (item == NULL) {
 260             free(key.dptr);
 261             Py_DECREF(v);
 262             return NULL;
 263         }
 264         err = PyList_Append(v, item);
 265         Py_DECREF(item);
 266         if (err != 0) {
 267             free(key.dptr);
 268             Py_DECREF(v);
 269             return NULL;
 270         }
 271         nextkey = gdbm_nextkey(dp->di_dbm, key);
 272         free(key.dptr);
 273         key = nextkey;
 274     }
 275     return v;
 276 }
 277
 278 PyDoc_STRVAR(dbm_has_key__doc__,
 279 "has_key(key) -> boolean\n\
 280 Find out whether or not the database contains a given key.");
 281
 282 static PyObject *
 283 dbm_has_key(register dbmobject *dp, PyObject *args)
 284 {
 285     datum key;
 286
 287     if (!PyArg_ParseTuple(args, "s#:has_key", &key.dptr, &key.dsize))
 288         return NULL;
 289     check_dbmobject_open(dp);
 290     return PyInt_FromLong((long) gdbm_exists(dp->di_dbm, key));
 291 }
 292
 293 PyDoc_STRVAR(dbm_firstkey__doc__,
 294 "firstkey() -> key\n\
 295 It's possible to loop over every key in the database using this method\n\
 296 and the nextkey() method. The traversal is ordered by GDBM's internal\n\
 297 hash values, and won't be sorted by the key values. This method\n\
 298 returns the starting key.");
 299
 300 static PyObject *
 301 dbm_firstkey(register dbmobject *dp, PyObject *unused)
 302 {
 303     register PyObject *v;
 304     datum key;
 305
 306     check_dbmobject_open(dp);
 307     key = gdbm_firstkey(dp->di_dbm);
 308     if (key.dptr) {
 309         v = PyString_FromStringAndSize(key.dptr, key.dsize);
 310         free(key.dptr);
 311         return v;
 312     }
 313     else {
 314         Py_INCREF(Py_None);
 315         return Py_None;
 316     }
 317 }
 318
 319 PyDoc_STRVAR(dbm_nextkey__doc__,
 320 "nextkey(key) -> next_key\n\
 321 Returns the key that follows key in the traversal.\n\
 322 The following code prints every key in the database db, without having\n\
 323 to create a list in memory that contains them all:\n\
 324 \n\
 325       k = db.firstkey()\n\
 326       while k != None:\n\
 327           print k\n\
 328           k = db.nextkey(k)");
 329
 330 static PyObject *
 331 dbm_nextkey(register dbmobject *dp, PyObject *args)
 332 {
 333     register PyObject *v;
 334     datum key, nextkey;
 335
 336     if (!PyArg_ParseTuple(args, "s#:nextkey", &key.dptr, &key.dsize))
 337         return NULL;
 338     check_dbmobject_open(dp);
 339     nextkey = gdbm_nextkey(dp->di_dbm, key);
 340     if (nextkey.dptr) {
 341         v = PyString_FromStringAndSize(nextkey.dptr, nextkey.dsize);
 342         free(nextkey.dptr);
 343         return v;
 344     }
 345     else {
 346         Py_INCREF(Py_None);
 347         return Py_None;
 348     }
 349 }
 350
 351 PyDoc_STRVAR(dbm_reorganize__doc__,
 352 "reorganize() -> None\n\
 353 If you have carried out a lot of deletions and would like to shrink\n\
 354 the space used by the GDBM file, this routine will reorganize the\n\
 355 database. GDBM will not shorten the length of a database file except\n\
 356 by using this reorganization; otherwise, deleted file space will be\n\
 357 kept and reused as new (key,value) pairs are added.");
 358
 359 static PyObject *
 360 dbm_reorganize(register dbmobject *dp, PyObject *unused)
 361 {
 362     check_dbmobject_open(dp);
 363     errno = 0;
 364     if (gdbm_reorganize(dp->di_dbm) < 0) {
 365         if (errno != 0)
 366             PyErr_SetFromErrno(DbmError);
 367         else
 368             PyErr_SetString(DbmError, gdbm_strerror(gdbm_errno));
 369         return NULL;
 370     }
 371     Py_INCREF(Py_None);
 372     return Py_None;
 373 }
 374
 375 PyDoc_STRVAR(dbm_sync__doc__,
 376 "sync() -> None\n\
 377 When the database has been opened in fast mode, this method forces\n\
 378 any unwritten data to be written to the disk.");
 379
 380 static PyObject *
 381 dbm_sync(register dbmobject *dp, PyObject *unused)
 382 {
 383     check_dbmobject_open(dp);
 384     gdbm_sync(dp->di_dbm);
 385     Py_INCREF(Py_None);
 386     return Py_None;
 387 }
 388
 389 static PyMethodDef dbm_methods[] = {
 390     {"close",     (PyCFunction)dbm_close,   METH_NOARGS, dbm_close__doc__},
 391     {"keys",      (PyCFunction)dbm_keys,    METH_NOARGS, dbm_keys__doc__},
 392     {"has_key",   (PyCFunction)dbm_has_key, METH_VARARGS, dbm_has_key__doc__},
 393     {"firstkey",  (PyCFunction)dbm_firstkey,METH_NOARGS, dbm_firstkey__doc__},
 394     {"nextkey",   (PyCFunction)dbm_nextkey, METH_VARARGS, dbm_nextkey__doc__},
 395     {"reorganize",(PyCFunction)dbm_reorganize,METH_NOARGS, dbm_reorganize__doc__},
 396     {"sync",      (PyCFunction)dbm_sync,    METH_NOARGS, dbm_sync__doc__},
 397     {NULL,              NULL}           /* sentinel */
 398 };
 399
 400 static PyObject *
 401 dbm_getattr(dbmobject *dp, char *name)
 402 {
 403     return Py_FindMethod(dbm_methods, (PyObject *)dp, name);
 404 }
 405
 406 static PyTypeObject Dbmtype = {
 407     PyVarObject_HEAD_INIT(0, 0)
 408     "gdbm.gdbm",
 409     sizeof(dbmobject),
 410     0,
 411     (destructor)dbm_dealloc,            /*tp_dealloc*/
 412     0,                                  /*tp_print*/
 413     (getattrfunc)dbm_getattr,           /*tp_getattr*/
 414     0,                                  /*tp_setattr*/
 415     0,                                  /*tp_compare*/
 416     0,                                  /*tp_repr*/
 417     0,                                  /*tp_as_number*/
 418     &dbm_as_sequence,                   /*tp_as_sequence*/
 419     &dbm_as_mapping,                    /*tp_as_mapping*/
 420     0,                                  /*tp_hash*/
 421     0,                                  /*tp_call*/
 422     0,                                  /*tp_str*/
 423     0,                                  /*tp_getattro*/
 424     0,                                  /*tp_setattro*/
 425     0,                                  /*tp_as_buffer*/
 426     Py_TPFLAGS_DEFAULT,                 /*tp_xxx4*/
 427     gdbm_object__doc__,                 /*tp_doc*/
 428 };
 429
 430 /* ----------------------------------------------------------------- */
 431
 432 PyDoc_STRVAR(dbmopen__doc__,
 433 "open(filename, [flags, [mode]])  -> dbm_object\n\
 434 Open a dbm database and return a dbm object. The filename argument is\n\
 435 the name of the database file.\n\
 436 \n\
 437 The optional flags argument can be 'r' (to open an existing database\n\
 438 for reading only -- default), 'w' (to open an existing database for\n\
 439 reading and writing), 'c' (which creates the database if it doesn't\n\
 440 exist), or 'n' (which always creates a new empty database).\n\
 441 \n\
 442 Some versions of gdbm support additional flags which must be\n\
 443 appended to one of the flags described above. The module constant\n\
 444 'open_flags' is a string of valid additional flags. The 'f' flag\n\
 445 opens the database in fast mode; altered data will not automatically\n\
 446 be written to the disk after every change. This results in faster\n\
 447 writes to the database, but may result in an inconsistent database\n\
 448 if the program crashes while the database is still open. Use the\n\
 449 sync() method to force any unwritten data to be written to the disk.\n\
 450 The 's' flag causes all database operations to be synchronized to\n\
 451 disk. The 'u' flag disables locking of the database file.\n\
 452 \n\
 453 The optional mode argument is the Unix mode of the file, used only\n\
 454 when the database has to be created. It defaults to octal 0666. ");
 455
 456 static PyObject *
 457 dbmopen(PyObject *self, PyObject *args)
 458 {
 459     char *name;
 460     char *flags = "r";
 461     int iflags;
 462     int mode = 0666;
 463
 464     if (!PyArg_ParseTuple(args, "s|si:open", &name, &flags, &mode))
 465         return NULL;
 466     switch (flags[0]) {
 467     case 'r':
 468         iflags = GDBM_READER;
 469         break;
 470     case 'w':
 471         iflags = GDBM_WRITER;
 472         break;
 473     case 'c':
 474         iflags = GDBM_WRCREAT;
 475         break;
 476     case 'n':
 477         iflags = GDBM_NEWDB;
 478         break;
 479     default:
 480         PyErr_SetString(DbmError,
 481                         "First flag must be one of 'r', 'w', 'c' or 'n'");
 482         return NULL;
 483     }
 484     for (flags++; *flags != '\0'; flags++) {
 485         char buf[40];
 486         switch (*flags) {
 487 #ifdef GDBM_FAST
 488             case 'f':
 489                 iflags |= GDBM_FAST;
 490                 break;
 491 #endif
 492 #ifdef GDBM_SYNC
 493             case 's':
 494                 iflags |= GDBM_SYNC;
 495                 break;
 496 #endif
 497 #ifdef GDBM_NOLOCK
 498             case 'u':
 499                 iflags |= GDBM_NOLOCK;
 500                 break;
 501 #endif
 502             default:
 503                 PyOS_snprintf(buf, sizeof(buf), "Flag '%c' is not supported.",
 504                               *flags);
 505                 PyErr_SetString(DbmError, buf);
 506                 return NULL;
 507         }
 508     }
 509
 510     return newdbmobject(name, iflags, mode);
 511 }
 512
 513 static char dbmmodule_open_flags[] = "rwcn"
 514 #ifdef GDBM_FAST
 515                                      "f"
 516 #endif
 517 #ifdef GDBM_SYNC
 518                                      "s"
 519 #endif
 520 #ifdef GDBM_NOLOCK
 521                                      "u"
 522 #endif
 523                                      ;
 524
 525 static PyMethodDef dbmmodule_methods[] = {
 526     { "open", (PyCFunction)dbmopen, METH_VARARGS, dbmopen__doc__},
 527     { 0, 0 },
 528 };
 529
 530 PyMODINIT_FUNC
 531 initgdbm(void) {
 532     PyObject *m, *d, *s;
 533
 534     Dbmtype.ob_type = &PyType_Type;
 535     m = Py_InitModule4("gdbm", dbmmodule_methods,
 536                        gdbmmodule__doc__, (PyObject *)NULL,
 537                        PYTHON_API_VERSION);
 538     if (m == NULL)
 539         return;
 540     d = PyModule_GetDict(m);
 541     DbmError = PyErr_NewException("gdbm.error", NULL, NULL);
 542     if (DbmError != NULL) {
 543         PyDict_SetItemString(d, "error", DbmError);
 544         s = PyString_FromString(dbmmodule_open_flags);
 545         PyDict_SetItemString(d, "open_flags", s);
 546         Py_DECREF(s);
 547     }
 548 }