Man Linux: Main Page and Category List

NAME

       dbm_clearerr,     dbm_close,    dbm_delete,    dbm_error,    dbm_fetch,
       dbm_firstkey, dbm_nextkey, dbm_open, dbm_store - database functions

SYNOPSIS

       #include <ndbm.h>

       int dbm_clearerr(DBM *db);
       void dbm_close(DBM *db);
       int dbm_delete(DBM *db, datum key);
       int dbm_error(DBM *db);
       datum dbm_fetch(DBM *db, datum key);
       datum dbm_firstkey(DBM *db);
       datum dbm_nextkey(DBM *db);
       DBM *dbm_open(const char *file, int open_flags, mode_t file_mode);
       int dbm_store(DBM *db, datum key, datum content, int store_mode);

DESCRIPTION

       These functions create, access, and modify a database.

       A datum consists of at least two members, dptr  and  dsize.   The  dptr
       member  points  to  an  object that is dsize bytes in length. Arbitrary
       binary data, as well as character strings, may be stored in the  object
       pointed to by dptr.

       The database is stored in two files. One file is a directory containing
       a bitmap of keys and has .dir as its suffix. The second  file  contains
       all data and has .pag as its suffix.

       The dbm_open() function shall open a database. The file argument to the
       function is the pathname of the database.  The function opens two files
       named  file.dir  and  file.pag.   The  open_flags argument has the same
       meaning as the flags argument of open() except that a  database  opened
       for write-only access opens the files for read and write access and the
       behavior of the O_APPEND flag is unspecified.  The  file_mode  argument
       has the same meaning as the third argument of open().

       The  dbm_close() function shall close a database. The application shall
       ensure that argument db is a pointer to a dbm structure that  has  been
       returned from a call to dbm_open().

       These  database  functions  shall  support an internal block size large
       enough to support key/content pairs of at least 1023 bytes.

       The dbm_fetch() function shall read a  record  from  a  database.   The
       argument db is a pointer to a database structure that has been returned
       from a call to dbm_open(). The argument key is a datum  that  has  been
       initialized by the application to the value of the key that matches the
       key of the record the program is fetching.

       The dbm_store() function shall write  a  record  to  a  database.   The
       argument db is a pointer to a database structure that has been returned
       from a call to dbm_open(). The argument key is a datum  that  has  been
       initialized  by the application to the value of the key that identifies
       (for  subsequent  reading,  writing,  or  deleting)  the   record   the
       application  is  writing. The argument content is a datum that has been
       initialized by the application to the value of the record  the  program
       is  writing.  The  argument  store_mode  controls  whether  dbm_store()
       replaces any  pre-existing  record  that  has  the  same  key  that  is
       specified  by the key argument. The application shall set store_mode to
       either DBM_INSERT or DBM_REPLACE. If the  database  contains  a  record
       that  matches  the  key  argument  and  store_mode  is DBM_REPLACE, the
       existing record shall be replaced with the new record. If the  database
       contains  a  record  that  matches  the  key argument and store_mode is
       DBM_INSERT, the existing record shall be left  unchanged  and  the  new
       record  ignored. If the database does not contain a record that matches
       the key argument and store_mode is either  DBM_INSERT  or  DBM_REPLACE,
       the new record shall be inserted in the database.

       If  the  sum of a key/content pair exceeds the internal block size, the
       result is unspecified. Moreover, the application shall ensure that  all
       key/content  pairs  that  hash  together  fit  on  a  single block. The
       dbm_store() function shall return an error in the  event  that  a  disk
       block fills with inseparable data.

       The  dbm_delete()  function  shall delete a record and its key from the
       database. The argument db is a pointer to a database structure that has
       been  returned  from a call to dbm_open().  The argument key is a datum
       that has been initialized by the application to the value  of  the  key
       that identifies the record the program is deleting.

       The dbm_firstkey() function shall return the first key in the database.
       The argument db is a pointer to a  database  structure  that  has  been
       returned from a call to dbm_open().

       The  dbm_nextkey()  function shall return the next key in the database.
       The argument db is a pointer to a  database  structure  that  has  been
       returned  from a call to dbm_open().  The application shall ensure that
       the dbm_firstkey() function is  called  before  calling  dbm_nextkey().
       Subsequent  calls to dbm_nextkey() return the next key until all of the
       keys in the database have been returned.

       The dbm_error() function  shall  return  the  error  condition  of  the
       database. The argument db is a pointer to a database structure that has
       been returned from a call to dbm_open().

       The dbm_clearerr() function shall clear  the  error  condition  of  the
       database. The argument db is a pointer to a database structure that has
       been returned from a call to dbm_open().

       The dptr pointers returned by these functions  may  point  into  static
       storage that may be changed by subsequent calls.

       These  functions need not be reentrant. A function that is not required
       to be reentrant is not required to be thread-safe.

RETURN VALUE

       The dbm_store() and dbm_delete() functions shall  return  0  when  they
       succeed and a negative value when they fail.

       The  dbm_store()  function  shall return 1 if it is called with a flags
       value of DBM_INSERT and the function finds an existing record with  the
       same key.

       The  dbm_error()  function shall return 0 if the error condition is not
       set and return a non-zero value if the error condition is set.

       The return value of dbm_clearerr() is unspecified.

       The dbm_firstkey() and  dbm_nextkey()  functions  shall  return  a  key
       datum.  When the end of the database is reached, the dptr member of the
       key is a null pointer. If an error is detected, the dptr member of  the
       key  shall  be  a  null pointer and the error condition of the database
       shall be set.

       The dbm_fetch() function shall return a content datum.  If no record in
       the database matches the key or if an error condition has been detected
       in the database, the dptr  member  of  the  content  shall  be  a  null
       pointer.

       The dbm_open() function shall return a pointer to a database structure.
       If an error is detected during the operation, dbm_open() shall return a
       ( DBM *)0.

ERRORS

       No errors are defined.

       The following sections are informative.

EXAMPLES

       None.

APPLICATION USAGE

       The following code can be used to traverse the database:

              for(key = dbm_firstkey(db); key.dptr != NULL; key = dbm_nextkey(db))

       The  dbm_* functions provided in this library should not be confused in
       any way with those of a  general-purpose  database  management  system.
       These functions do not provide for multiple search keys per entry, they
       do not protect against multi-user access (in other words  they  do  not
       lock  records  or files), and they do not provide the many other useful
       database functions that are found in more  robust  database  management
       systems.  Creating  and updating databases by use of these functions is
       relatively slow because of data copies that occur upon hash collisions.
       These  functions  are  useful for applications requiring fast lookup of
       relatively static information that is to be indexed by a single key.

       Note that a strictly conforming application  is  extremely  limited  by
       these  functions:  since  there is no way to determine that the keys in
       use do not all hash to the same value (although that would be rare),  a
       strictly  conforming application cannot be guaranteed that it can store
       more than one block’s worth of data in the database.  As long as a  key
       collision  does  not  occur, additional data may be stored, but because
       there is no way to determine whether an error is due to a key collision
       or  some  other  error  condition  (  dbm_error()  being  effectively a
       Boolean), once an error is detected,  the  application  is  effectively
       limited  to  guessing  what the error might be if it wishes to continue
       using these functions.

       The dbm_delete() function  need  not  physically  reclaim  file  space,
       although it does make it available for reuse by the database.

       After  calling  dbm_store()  or  dbm_delete() during a pass through the
       keys by dbm_firstkey() and dbm_nextkey(), the application should  reset
       the   database   by   calling   dbm_firstkey()   before  again  calling
       dbm_nextkey(). The contents of these files are unspecified and may  not
       be portable.

RATIONALE

       None.

FUTURE DIRECTIONS

       None.

SEE ALSO

       open() , the Base Definitions volume of IEEE Std 1003.1-2001, <ndbm.h>

COPYRIGHT

       Portions  of  this text are reprinted and reproduced in electronic form
       from IEEE Std 1003.1, 2003 Edition, Standard for Information Technology
       --  Portable  Operating  System  Interface (POSIX), The Open Group Base
       Specifications Issue 6, Copyright (C) 2001-2003  by  the  Institute  of
       Electrical  and  Electronics  Engineers, Inc and The Open Group. In the
       event of any discrepancy between this version and the original IEEE and
       The  Open Group Standard, the original IEEE and The Open Group Standard
       is the referee document. The original Standard can be  obtained  online
       at http://www.opengroup.org/unix/online.html .