Back to index

python3.2  3.2.2
Classes | Defines | Functions | Variables
_gdbmmodule.c File Reference
#include "Python.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "gdbm.h"

Go to the source code of this file.

Classes

struct  dbmobject

Defines

#define is_dbmobject(v)   (Py_TYPE(v) == &Dbmtype)
#define check_dbmobject_open(v)

Functions

 PyDoc_STRVAR (gdbmmodule__doc__,"This module provides an interface to the GNU DBM (GDBM) library.\n\ \n\ This module is quite similar to the dbm module, but uses GDBM instead to\n\ provide some additional functionality. Please note that the file formats\n\ created by GDBM and dbm are incompatible. \n\ \n\ GDBM objects behave like mappings (dictionaries), except that keys and\n\ values are always strings. Printing a GDBM object doesn't print the\n\ keys and values, and the items() and values() methods are not\n\ supported.")
 PyDoc_STRVAR (gdbm_object__doc__,"This object represents a GDBM database.\n\ GDBM objects behave like mappings (dictionaries), except that keys and\n\ values are always strings. Printing a GDBM object doesn't print the\n\ keys and values, and the items() and values() methods are not\n\ supported.\n\ \n\ GDBM objects also support additional operations such as firstkey,\n\ nextkey, reorganize, and sync.")
static PyObjectnewdbmobject (char *file, int flags, int mode)
static void dbm_dealloc (register dbmobject *dp)
static Py_ssize_t dbm_length (dbmobject *dp)
static PyObjectdbm_subscript (dbmobject *dp, register PyObject *key)
 PyDoc_STRVAR (dbm_get__doc__,"get(key[, default]) -> value\n\ Get the value for key, or default if not present; if not given,\n\ default is None.")
static PyObjectdbm_get (dbmobject *dp, PyObject *args)
static int dbm_ass_sub (dbmobject *dp, PyObject *v, PyObject *w)
 PyDoc_STRVAR (dbm_setdefault__doc__,"setdefault(key[, default]) -> value\n\ Get value for key, or set it to default and return default if not present;\n\ if not given, default is None.")
static PyObjectdbm_setdefault (dbmobject *dp, PyObject *args)
 PyDoc_STRVAR (dbm_close__doc__,"close() -> None\n\ Closes the database.")
static PyObjectdbm_close (register dbmobject *dp, PyObject *unused)
 PyDoc_STRVAR (dbm_keys__doc__,"keys() -> list_of_keys\n\ Get a list of all keys in the database.")
static PyObjectdbm_keys (register dbmobject *dp, PyObject *unused)
static int dbm_contains (PyObject *self, PyObject *arg)
 PyDoc_STRVAR (dbm_firstkey__doc__,"firstkey() -> key\n\ It's possible to loop over every key in the database using this method\n\ and the nextkey() method. The traversal is ordered by GDBM's internal\n\ hash values, and won't be sorted by the key values. This method\n\ returns the starting key.")
static PyObjectdbm_firstkey (register dbmobject *dp, PyObject *unused)
 PyDoc_STRVAR (dbm_nextkey__doc__,"nextkey(key) -> next_key\n\ Returns the key that follows key in the traversal.\n\ The following code prints every key in the database db, without having\n\ to create a list in memory that contains them all:\n\ \n\ k = db.firstkey()\n\ while k != None:\n\ print k\n\ k = db.nextkey(k)")
static PyObjectdbm_nextkey (register dbmobject *dp, PyObject *args)
 PyDoc_STRVAR (dbm_reorganize__doc__,"reorganize() -> None\n\ If you have carried out a lot of deletions and would like to shrink\n\ the space used by the GDBM file, this routine will reorganize the\n\ database. GDBM will not shorten the length of a database file except\n\ by using this reorganization; otherwise, deleted file space will be\n\ kept and reused as new (key,value) pairs are added.")
static PyObjectdbm_reorganize (register dbmobject *dp, PyObject *unused)
 PyDoc_STRVAR (dbm_sync__doc__,"sync() -> None\n\ When the database has been opened in fast mode, this method forces\n\ any unwritten data to be written to the disk.")
static PyObjectdbm_sync (register dbmobject *dp, PyObject *unused)
 PyDoc_STRVAR (dbmopen__doc__,"open(filename, [flags, [mode]]) -> dbm_object\n\ Open a dbm database and return a dbm object. The filename argument is\n\ the name of the database file.\n\ \n\ The optional flags argument can be 'r' (to open an existing database\n\ for reading only -- default), 'w' (to open an existing database for\n\ reading and writing), 'c' (which creates the database if it doesn't\n\ exist), or 'n' (which always creates a new empty database).\n\ \n\ Some versions of gdbm support additional flags which must be\n\ appended to one of the flags described above. The module constant\n\ 'open_flags' is a string of valid additional flags. The 'f' flag\n\ opens the database in fast mode; altered data will not automatically\n\ be written to the disk after every change. This results in faster\n\ writes to the database, but may result in an inconsistent database\n\ if the program crashes while the database is still open. Use the\n\ sync() method to force any unwritten data to be written to the disk.\n\ The 's' flag causes all database operations to be synchronized to\n\ disk. The 'u' flag disables locking of the database file.\n\ \n\ The optional mode argument is the Unix mode of the file, used only\n\ when the database has to be created. It defaults to octal 0666. ")
static PyObjectdbmopen (PyObject *self, PyObject *args)
PyMODINIT_FUNC PyInit__gdbm (void)

Variables

static PyTypeObject Dbmtype
static PyObjectDbmError
static PyMappingMethods dbm_as_mapping
static PySequenceMethods dbm_as_sequence
static PyMethodDef dbm_methods []
static char dbmmodule_open_flags [] = "rwcn"
static PyMethodDef dbmmodule_methods []
static struct PyModuleDef

Class Documentation

struct dbmobject

Definition at line 35 of file _dbmmodule.c.

Class Members
GDBM_FILE di_dbm
DBM * di_dbm
PyObject_HEAD int di_size

Define Documentation

#define check_dbmobject_open (   v)
Value:
if ((v)->di_dbm == NULL) \
    { PyErr_SetString(DbmError, "GDBM object has already been closed"); \
      return NULL; }

Definition at line 40 of file _gdbmmodule.c.

#define is_dbmobject (   v)    (Py_TYPE(v) == &Dbmtype)

Definition at line 39 of file _gdbmmodule.c.


Function Documentation

static int dbm_ass_sub ( dbmobject dp,
PyObject v,
PyObject w 
) [static]

Definition at line 161 of file _gdbmmodule.c.

{
    datum krec, drec;

    if (!PyArg_Parse(v, "s#", &krec.dptr, &krec.dsize) ) {
        PyErr_SetString(PyExc_TypeError,
                        "gdbm mappings have bytes or string indices only");
        return -1;
    }
    if (dp->di_dbm == NULL) {
        PyErr_SetString(DbmError,
                        "GDBM object has already been closed");
        return -1;
    }
    dp->di_size = -1;
    if (w == NULL) {
        if (gdbm_delete(dp->di_dbm, krec) < 0) {
            PyErr_SetObject(PyExc_KeyError, v);
            return -1;
        }
    }
    else {
        if (!PyArg_Parse(w, "s#", &drec.dptr, &drec.dsize)) {
            PyErr_SetString(PyExc_TypeError,
                            "gdbm mappings have byte or string elements only");
            return -1;
        }
        errno = 0;
        if (gdbm_store(dp->di_dbm, krec, drec, GDBM_REPLACE) < 0) {
            if (errno != 0)
                PyErr_SetFromErrno(DbmError);
            else
                PyErr_SetString(DbmError,
                                gdbm_strerror(gdbm_errno));
            return -1;
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* dbm_close ( register dbmobject dp,
PyObject unused 
) [static]

Definition at line 235 of file _gdbmmodule.c.

{
    if (dp->di_dbm)
        gdbm_close(dp->di_dbm);
    dp->di_dbm = NULL;
    Py_INCREF(Py_None);
    return Py_None;
}

Here is the caller graph for this function:

static int dbm_contains ( PyObject self,
PyObject arg 
) [static]

Definition at line 289 of file _gdbmmodule.c.

{
    dbmobject *dp = (dbmobject *)self;
    datum key;

    if ((dp)->di_dbm == NULL) {
        PyErr_SetString(DbmError,
                        "GDBM object has already been closed");
        return -1;
    }
    if (!PyBytes_Check(arg)) {
        PyErr_Format(PyExc_TypeError,
                     "gdbm key must be bytes, not %.100s",
                     arg->ob_type->tp_name);
        return -1;
    }
    key.dptr = PyBytes_AS_STRING(arg);
    key.dsize = PyBytes_GET_SIZE(arg);
    return gdbm_exists(dp->di_dbm, key);
}

Here is the call graph for this function:

static void dbm_dealloc ( register dbmobject dp) [static]

Definition at line 82 of file _gdbmmodule.c.

{
    if (dp->di_dbm)
        gdbm_close(dp->di_dbm);
    PyObject_Del(dp);
}
static PyObject* dbm_firstkey ( register dbmobject dp,
PyObject unused 
) [static]

Definition at line 331 of file _gdbmmodule.c.

{
    register PyObject *v;
    datum key;

    check_dbmobject_open(dp);
    key = gdbm_firstkey(dp->di_dbm);
    if (key.dptr) {
        v = PyBytes_FromStringAndSize(key.dptr, key.dsize);
        free(key.dptr);
        return v;
    }
    else {
        Py_INCREF(Py_None);
        return Py_None;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* dbm_get ( dbmobject dp,
PyObject args 
) [static]

Definition at line 144 of file _gdbmmodule.c.

{
    PyObject *v, *res;
    PyObject *def = Py_None;

    if (!PyArg_UnpackTuple(args, "get", 1, 2, &v, &def))
        return NULL;
    res = dbm_subscript(dp, v);
    if (res == NULL && PyErr_ExceptionMatches(PyExc_KeyError)) {
        PyErr_Clear();
        Py_INCREF(def);
        return def;
    }
    return res;
}

Here is the call graph for this function:

static PyObject* dbm_keys ( register dbmobject dp,
PyObject unused 
) [static]

Definition at line 250 of file _gdbmmodule.c.

{
    register PyObject *v, *item;
    datum key, nextkey;
    int err;

    if (dp == NULL || !is_dbmobject(dp)) {
        PyErr_BadInternalCall();
        return NULL;
    }
    check_dbmobject_open(dp);

    v = PyList_New(0);
    if (v == NULL)
        return NULL;

    key = gdbm_firstkey(dp->di_dbm);
    while (key.dptr) {
        item = PyBytes_FromStringAndSize(key.dptr, key.dsize);
        if (item == NULL) {
            free(key.dptr);
            Py_DECREF(v);
            return NULL;
        }
        err = PyList_Append(v, item);
        Py_DECREF(item);
        if (err != 0) {
            free(key.dptr);
            Py_DECREF(v);
            return NULL;
        }
        nextkey = gdbm_nextkey(dp->di_dbm, key);
        free(key.dptr);
        key = nextkey;
    }
    return v;
}

Here is the call graph for this function:

static Py_ssize_t dbm_length ( dbmobject dp) [static]

Definition at line 90 of file _gdbmmodule.c.

{
    if (dp->di_dbm == NULL) {
        PyErr_SetString(DbmError, "GDBM object has already been closed");
        return -1;
    }
    if (dp->di_size < 0) {
        datum key,okey;
        int size;
        okey.dsize=0;
        okey.dptr=NULL;

        size = 0;
        for (key=gdbm_firstkey(dp->di_dbm); key.dptr;
             key = gdbm_nextkey(dp->di_dbm,okey)) {
            size++;
            if(okey.dsize) free(okey.dptr);
            okey=key;
        }
        dp->di_size = size;
    }
    return dp->di_size;
}

Here is the call graph for this function:

static PyObject* dbm_nextkey ( register dbmobject dp,
PyObject args 
) [static]

Definition at line 361 of file _gdbmmodule.c.

{
    register PyObject *v;
    datum key, nextkey;

    if (!PyArg_ParseTuple(args, "s#:nextkey", &key.dptr, &key.dsize))
        return NULL;
    check_dbmobject_open(dp);
    nextkey = gdbm_nextkey(dp->di_dbm, key);
    if (nextkey.dptr) {
        v = PyBytes_FromStringAndSize(nextkey.dptr, nextkey.dsize);
        free(nextkey.dptr);
        return v;
    }
    else {
        Py_INCREF(Py_None);
        return Py_None;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* dbm_reorganize ( register dbmobject dp,
PyObject unused 
) [static]

Definition at line 390 of file _gdbmmodule.c.

{
    check_dbmobject_open(dp);
    errno = 0;
    if (gdbm_reorganize(dp->di_dbm) < 0) {
        if (errno != 0)
            PyErr_SetFromErrno(DbmError);
        else
            PyErr_SetString(DbmError, gdbm_strerror(gdbm_errno));
        return NULL;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

Here is the call graph for this function:

static PyObject* dbm_setdefault ( dbmobject dp,
PyObject args 
) [static]

Definition at line 207 of file _gdbmmodule.c.

{
    PyObject *v, *res;
    PyObject *def = Py_None;

    if (!PyArg_UnpackTuple(args, "setdefault", 1, 2, &v, &def))
        return NULL;
    res = dbm_subscript(dp, v);
    if (res == NULL && PyErr_ExceptionMatches(PyExc_KeyError)) {
        PyErr_Clear();
        if (dbm_ass_sub(dp, v, def) < 0)
            return NULL;
        return dbm_subscript(dp, v);
    }
    return res;
}

Here is the call graph for this function:

static PyObject* dbm_subscript ( dbmobject dp,
register PyObject key 
) [static]

Definition at line 115 of file _gdbmmodule.c.

{
    PyObject *v;
    datum drec, krec;

    if (!PyArg_Parse(key, "s#", &krec.dptr, &krec.dsize) )
        return NULL;

    if (dp->di_dbm == NULL) {
        PyErr_SetString(DbmError,
                        "GDBM object has already been closed");
        return NULL;
    }
    drec = gdbm_fetch(dp->di_dbm, krec);
    if (drec.dptr == 0) {
        PyErr_SetObject(PyExc_KeyError, key);
        return NULL;
    }
    v = PyBytes_FromStringAndSize(drec.dptr, drec.dsize);
    free(drec.dptr);
    return v;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* dbm_sync ( register dbmobject dp,
PyObject unused 
) [static]

Definition at line 411 of file _gdbmmodule.c.

{
    check_dbmobject_open(dp);
    gdbm_sync(dp->di_dbm);
    Py_INCREF(Py_None);
    return Py_None;
}
static PyObject* dbmopen ( PyObject self,
PyObject args 
) [static]

Definition at line 489 of file _gdbmmodule.c.

{
    char *name;
    char *flags = "r";
    int iflags;
    int mode = 0666;

    if (!PyArg_ParseTuple(args, "s|si:open", &name, &flags, &mode))
        return NULL;
    switch (flags[0]) {
    case 'r':
        iflags = GDBM_READER;
        break;
    case 'w':
        iflags = GDBM_WRITER;
        break;
    case 'c':
        iflags = GDBM_WRCREAT;
        break;
    case 'n':
        iflags = GDBM_NEWDB;
        break;
    default:
        PyErr_SetString(DbmError,
                        "First flag must be one of 'r', 'w', 'c' or 'n'");
        return NULL;
    }
    for (flags++; *flags != '\0'; flags++) {
        char buf[40];
        switch (*flags) {
#ifdef GDBM_FAST
            case 'f':
                iflags |= GDBM_FAST;
                break;
#endif
#ifdef GDBM_SYNC
            case 's':
                iflags |= GDBM_SYNC;
                break;
#endif
#ifdef GDBM_NOLOCK
            case 'u':
                iflags |= GDBM_NOLOCK;
                break;
#endif
            default:
                PyOS_snprintf(buf, sizeof(buf), "Flag '%c' is not supported.",
                              *flags);
                PyErr_SetString(DbmError, buf);
                return NULL;
        }
    }

    return newdbmobject(name, iflags, mode);
}

Here is the call graph for this function:

static PyObject* newdbmobject ( char *  file,
int  flags,
int  mode 
) [static]

Definition at line 59 of file _gdbmmodule.c.

{
    dbmobject *dp;

    dp = PyObject_New(dbmobject, &Dbmtype);
    if (dp == NULL)
        return NULL;
    dp->di_size = -1;
    errno = 0;
    if ((dp->di_dbm = gdbm_open(file, 0, flags, mode, NULL)) == 0) {
        if (errno != 0)
            PyErr_SetFromErrno(DbmError);
        else
            PyErr_SetString(DbmError, gdbm_strerror(gdbm_errno));
        Py_DECREF(dp);
        return NULL;
    }
    return (PyObject *)dp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyDoc_STRVAR ( gdbmmodule__doc__  ,
"This module provides an interface to the GNU DBM (GDBM) library.\n\\n\This module is quite similar to the dbm  module,
but uses GDBM instead to\n\provide some additional functionality.Please note that the file formats\n\created by GDBM and dbm are incompatible.\n\\n\GDBM objects behave like   mappingsdictionaries,
except that keys and\n\values are always strings.Printing a GDBM object doesn't print the\n\keys and  values,
and the items() and values() methods are not\n\supported."   
)
PyDoc_STRVAR ( gdbm_object__doc__  ,
"This object represents a GDBM database.\n\GDBM objects behave like mappings   dictionaries,
except that keys and\n\values are always strings.Printing a GDBM object doesn't print the\n\keys and  values,
and the items() and values() methods are not\n\supported.\n\\n\GDBM objects also support additional operations such as  firstkey,
\n\  nextkey,
reorganize  ,
and sync."   
)
PyDoc_STRVAR ( dbm_get__doc__  ,
"get(key[, default]) -> value\n\Get the value for  key,
or default if not present;if not  given,
\n\default is None."   
)
PyDoc_STRVAR ( dbm_setdefault__doc__  ,
"setdefault(key[, default]) -> value\n\Get value for  key,
or set it to default and return default if not present;\n\if not  given,
default is None."   
)
PyDoc_STRVAR ( dbm_close__doc__  ,
"close() -> None\n\Closes the database."   
)
PyDoc_STRVAR ( dbm_keys__doc__  ,
"keys() -> list_of_keys\n\Get a list of all keys in the database."   
)
PyDoc_STRVAR ( dbm_firstkey__doc__  ,
"firstkey() -> key\n\It's possible to loop over every key in the database using this method\n\and the nextkey() method. The traversal is ordered by GDBM's internal\n\hash  values,
and won't be sorted by the key values.This method\n\returns the starting key."   
)
PyDoc_STRVAR ( dbm_nextkey__doc__  ,
"nextkey(key) -> next_key\n\Returns the key that follows key in the traversal.\n\The following code prints every key in the database  db 
)
PyDoc_STRVAR ( dbm_reorganize__doc__  ,
"reorganize() -> None\n\If you have carried out a lot of deletions and would like to shrink\n\the space used by the GDBM  file,
this routine will reorganize the\n\database.GDBM will not shorten the length of a database file except\n\by using this reorganization;  otherwise,
deleted file space will be\n\kept and reused as new(key, value) pairs are added."   
)
PyDoc_STRVAR ( dbm_sync__doc__  ,
"sync() -> None\n\When the database has been opened in fast  mode,
this method forces\n\any unwritten data to be written to the disk."   
)
PyDoc_STRVAR ( dbmopen__doc__  ,
openfilename, [flags, [mode]]) -> dbm_object\n\Open a dbm database and return a dbm object. The filename argument is\n\the name of the database file.\n\\n\The optional flags argument can be 'r' (to open an existing database\n\for reading only -- default,
'w'  to open an existing database for\n\reading and writing,
'c which creates the database if it doesn't\n\exist,
or 'n'(which always creates a new empty database).\n\\n\Some versions of gdbm support additional flags which must be\n\appended to one of the flags described above.The module constant\n\'open_flags'is a string of valid additional flags.The 'f'flag\n\opens the database in fast mode;altered data will not automatically\n\be written to the disk after every change.This results in faster\n\writes to the  database,
but may result in an inconsistent database\n\if the program crashes while the database is still open.Use the\n\sync() method to force any unwritten data to be written to the disk.\n\The 's'flag causes all database operations to be synchronized to\n\disk.The 'u'flag disables locking of the database file.\n\\n\The optional mode argument is the Unix mode of the  file,
used only\n\when the database has to be created.It defaults to octal 0666."   
)

Definition at line 576 of file _gdbmmodule.c.

                   {
    PyObject *m, *d, *s;

    if (PyType_Ready(&Dbmtype) < 0)
            return NULL;
    m = PyModule_Create(&_gdbmmodule);
    if (m == NULL)
        return NULL;
    d = PyModule_GetDict(m);
    DbmError = PyErr_NewException("_gdbm.error", PyExc_IOError, NULL);
    if (DbmError != NULL) {
        PyDict_SetItemString(d, "error", DbmError);
        s = PyUnicode_FromString(dbmmodule_open_flags);
        PyDict_SetItemString(d, "open_flags", s);
        Py_DECREF(s);
    }
    return m;
}

Here is the call graph for this function:


Variable Documentation

Initial value:

Definition at line 224 of file _gdbmmodule.c.

Initial value:
 {
        0,                      
        0,                      
        0,                      
        0,                      
        0,                      
        0,                      
        0,                      
        dbm_contains,           
        0,                      
        0,                      
}

Definition at line 310 of file _gdbmmodule.c.

Initial value:
 {
    {"close",     (PyCFunction)dbm_close,   METH_NOARGS, dbm_close__doc__},
    {"keys",      (PyCFunction)dbm_keys,    METH_NOARGS, dbm_keys__doc__},
    {"firstkey",  (PyCFunction)dbm_firstkey,METH_NOARGS, dbm_firstkey__doc__},
    {"nextkey",   (PyCFunction)dbm_nextkey, METH_VARARGS, dbm_nextkey__doc__},
    {"reorganize",(PyCFunction)dbm_reorganize,METH_NOARGS, dbm_reorganize__doc__},
    {"sync",      (PyCFunction)dbm_sync,    METH_NOARGS, dbm_sync__doc__},
    {"get",       (PyCFunction)dbm_get,     METH_VARARGS, dbm_get__doc__},
    {"setdefault",(PyCFunction)dbm_setdefault,METH_VARARGS, dbm_setdefault__doc__},
    {NULL,              NULL}           
}

Definition at line 419 of file _gdbmmodule.c.

PyObject* DbmError [static]

Definition at line 46 of file _gdbmmodule.c.

Initial value:
 {
    { "open", (PyCFunction)dbmopen, METH_VARARGS, dbmopen__doc__},
    { 0, 0 },
}

Definition at line 557 of file _gdbmmodule.c.

char dbmmodule_open_flags[] = "rwcn" [static]

Definition at line 545 of file _gdbmmodule.c.

static PyTypeObject Dbmtype [static]
Initial value:
 {
    PyVarObject_HEAD_INIT(0, 0)
    "_gdbm.gdbm",
    sizeof(dbmobject),
    0,
    (destructor)dbm_dealloc,            
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    &dbm_as_sequence,                   
    &dbm_as_mapping,                    
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    Py_TPFLAGS_DEFAULT,                 
    gdbm_object__doc__,                 
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    0,                                  
    dbm_methods,                        
}

Definition at line 37 of file _gdbmmodule.c.

struct PyModuleDef [static]
Initial value:
 {
        PyModuleDef_HEAD_INIT,
        "_gdbm",
        gdbmmodule__doc__,
        -1,
        dbmmodule_methods,
        NULL,
        NULL,
        NULL,
        NULL
}

Definition at line 563 of file _gdbmmodule.c.