NAME¶
GDBM - The GNU database manager. Includes
dbm and
ndbm
compatability. (Version 1.8.3.)
SYNOPSIS¶
#include <gdbm.h>
extern gdbm_error
gdbm_errno
extern char
*gdbm_version
GDBM_FILE
gdbm_open (name, block_size, read_write, mode, fatal_func)
char * name;
int block_size, read_write, mode;
void (*fatal_func) ();
void
gdbm_close (dbf)
GDBM_FILE dbf;
int
gdbm_store (dbf, key, content, flag)
GDBM_FILE dbf;
datum key, content;
int flag;
datum
gdbm_fetch (dbf, key)
GDBM_FILE dbf;
datum key;
int
gdbm_delete (dbf, key)
GDBM_FILE dbf;
datum key;
datum
gdbm_firstkey (dbf)
GDBM_FILE dbf;
datum
gdbm_nextkey (dbf, key)
GDBM_FILE dbf;
datum key;
int
gdbm_reorganize (dbf)
GDBM_FILE dbf;
void
gdbm_sync (dbf)
GDBM_FILE dbf;
int
gdbm_exists (dbf, key)
GDBM_FILE dbf;
datum key;
char *
gdbm_strerror (errno)
gdbm_error errno;
int
gdbm_setopt (dbf, option, value, size)
GDBM_FILE dbf;
int option;
int *value;
int size;
int
gdbm_fdesc (dbf)
GDBM_FILE dbf;
DBM Compatability routines:
#include <dbm.h>
int
dbminit (name)
char *name;
int
store (key, content)
datum key, content;
datum
fetch (key)
datum key;
int
delete (key)
datum key;
datum
firstkey ()
datum
nextkey (key)
datum key;
int
dbmclose ()
NDBM Compatability routines:
#include <ndbm.h>
DBM
*dbm_open (name, flags, mode)
char *name;
int flags, mode;
void
dbm_close (file)
DBM *file;
datum
dbm_fetch (file, key)
DBM *file;
datum key;
int
dbm_store (file, key, content, flags)
DBM *file;
datum key, content;
int flags;
int
dbm_delete (file, key)
DBM *file;
datum key;
datum
dbm_firstkey (file)
DBM *file;
datum
dbm_nextkey (file)
DBM *file;
int
dbm_error (file)
DBM *file;
int
dbm_clearerr (file)
DBM *file;
int
dbm_pagfno (file)
DBM *file;
int
dbm_dirfno (file)
DBM *file;
int
dbm_rdonly (file)
DBM *file;
DESCRIPTION¶
GNU dbm is a library of routines that manages data files that contain key/data
pairs. The access provided is that of storing, retrieval, and deletion by key
and a non-sorted traversal of all keys. A process is allowed to use multiple
data files at the same time.
A process that opens a gdbm file is designated as a "reader" or a
"writer". Only one writer may open a gdbm file and many readers may
open the file. Readers and writers can not open the gdbm file at the same
time. The procedure for opening a gdbm file is:
GDBM_FILE dbf;
dbf = gdbm_open ( name, block_size, read_write, mode, fatal_func )
Name is the name of the file (the complete name, gdbm does not append any
characters to this name).
Block_size is the size of a single transfer
from disk to memory. This parameter is ignored unless the file is a new file.
The minimum size is 512. If it is less than 512, dbm will use the stat block
size for the file system.
Read_write can have one of the following
values:
GDBM_READER reader
GDBM_WRITER writer
GDBM_WRCREAT writer - if database does not exist create new one
GDBM_NEWDB writer - create new database regardless if one exists
For the last three (writers of the database) the following may be added added to
read_write by bitwise or:
GDBM_SYNC, which causes all database
operations to be synchronized to the disk, and
GDBM_NOLOCK, which
prevents the library from performing any locking on the database file. The
option
GDBM_FAST is now obsolete, since gdbm defaults to no-sync mode.
Mode is the file mode (see
chmod(2) and
open(2)) if the
file is created.
(*Fatal_func) () is a function for dbm to call if it
detects a fatal error. The only parameter of this function is a string. If the
value of 0 is provided, gdbm will use a default function.
The return value
dbf is the pointer needed by all other routines to
access that gdbm file. If the return is the NULL pointer,
gdbm_open was
not successful. The errors can be found in
gdbm_errno for gdbm errors
and in
errno for system errors. (For error codes, see gdbmerrno.h.)
In all of the following calls, the parameter
dbf refers to the pointer
returned from
gdbm_open.
It is important that every file opened is also closed. This is needed to update
the reader/writer count on the file. This is done by:
gdbm_close (dbf);
The database is used by 3 primary routines. The first stores data in the
database.
ret = gdbm_store ( dbf, key, content, flag )
Dbf is the pointer returned by
gdbm_open.
Key is the key
data.
Content is the data to be associated with the
key.
Flag can have one of the following values:
GDBM_INSERT insert only, generate an error if key exists
GDBM_REPLACE replace contents if key exists.
If a reader calls
gdbm_store, the return value will be -1. If called with
GDBM_INSERT and
key is in the database, the return value will be 1.
Otherwise, the return value is 0.
NOTICE: If you store data for a key that is already in the data base,
gdbm replaces the old data with the new data if called with
GDBM_REPLACE. You do not get two data items for the same key and you do
not get an error from gdbm_store.
NOTICE: The size in gdbm is not restricted like dbm or ndbm. Your data can be as
large as you want.
To search for some data:
content = gdbm_fetch ( dbf, key )
Dbf is the pointer returned by
gdbm_open.
Key is the key
data.
If the
dptr element of the return value is NULL, no data was found.
Otherwise the return value is a pointer to the found data. The storage space
for the
dptr element is allocated using
malloc(3C).
Gdbm does not automatically free this data. It is the
programmer's responsibility to free this storage when it is no longer
needed.
To search for some data, without retrieving it:
ret = gdbm_exists ( dbf, key )
Dbf is the pointer returned by
gdbm_open.
Key is the key
data to search for.
If the
key is found within the database, the return value
ret will
be true. If nothing appropiate is found,
ret will be false. This
routine is useful for checking for the existance of a record, without
performing the memory allocation done by
gdbm_fetch.
To remove some data from the database:
ret = gdbm_delete ( dbf, key )
Dbf is the pointer returned by
gdbm_open.
Key is the key
data.
The return value is -1 if the item is not present or the requester is a reader.
The return value is 0 if there was a successful delete.
The next two routines allow for accessing all items in the database. This access
is not key sequential, but it is guaranteed to visit every key in the database
once. (The order has to do with the hash values.)
key = gdbm_firstkey ( dbf )
nextkey = gdbm_nextkey ( dbf, key )
Dbf is the pointer returned by
gdbm_open.
Key is the key
data.
The return values are both of type
datum. If the
dptr element of
the return value is NULL, there is no first key or next key. Again notice that
dptr points to data allocated by
malloc(3C) and
gdbm will
not free it for you.
These functions were intended to visit the database in read-only algorithms, for
instance, to validate the database or similar operations.
File `visiting' is based on a `hash table'.
gdbm_delete re-arranges the
hash table to make sure that any collisions in the table do not leave some
item `un-findable'. The original key order is NOT guaranteed to remain
unchanged in ALL instances. It is possible that some key will not be visited
if a loop like the following is executed:
key = gdbm_firstkey ( dbf );
while ( key.dptr ) {
nextkey = gdbm_nextkey ( dbf, key );
if ( some condition ) {
gdbm_delete ( dbf, key );
free ( key.dptr );
}
key = nextkey;
}
The following routine should be used very infrequently.
ret = gdbm_reorganize ( dbf )
If you have had a lot of deletions and would like to shrink the space used by
the
gdbm file, this routine will reorganize the database.
Gdbm
will not shorten the length of a
gdbm file except by using this
reorganization. (Deleted file space will be reused.)
Unless your database was opened with the GDBM_SYNC flag, gdbm does not wait for
writes to be flushed to the disk before continuing. The following routine can
be used to guarantee that the database is physically written to the disk file.
gdbm_sync ( dbf )
It will not return until the disk file state is syncronized with the in-memory
state of the database.
To convert a
gdbm error code into English text, use this routine:
ret = gdbm_strerror ( errno )
Where
errno is of type
gdbm_error, usually the global variable
gdbm_errno. The appropiate phrase is returned.
Gdbm now supports the ability to set certain options on an already open
database.
ret = gdbm_setopt ( dbf, option, value, size )
Where
dbf is the return value from a previous call to
gdbm_open,
and
option specifies which option to set. The valid options are
currently:
GDBM_CACHESIZE - Set the size of the internal bucket
cache. This option may only be set once on each
GDBM_FILE
descriptor, and is set automatically to 100 upon the first
access to the database.
GDBM_FASTMODE - Set
fast mode to either on or off. This
allows
fast mode to be toggled on an already open and
active database.
value (see below) should be set to either
TRUE or FALSE.
This option is now obsolete.
GDBM_SYNCMODE - Turn on or off file system synchronization operations.
This setting defaults to off;
value (see below) should be set to either
TRUE or FALSE.
GDBM_CENTFREE - Set
central free block pool to either on or off.
The default is off, which is how previous versions of
Gdbm
handled free blocks. If set, this option causes all subsequent free
blocks to be placed in the
global pool, allowing (in thoery)
more file space to be reused more quickly.
value (see below) should
be set to either TRUE or FALSE.
NOTICE: This feature is still under study.
GDBM_COALESCEBLKS - Set
free block merging to either on or off.
The default is off, which is how previous versions of
Gdbm
handled free blocks. If set, this option causes adjacent free blocks
to be merged. This can become a CPU expensive process with time, though,
especially if used in conjunction with
GDBM_CENTFREE.
value
(see below) should be set to either TRUE or FALSE.
NOTICE: This feature is still under study.
value is the value to set
option to, specified as an integer
pointer.
size is the size of the data pointed to by
value. The
return value will be -1 upon failure, or 0 upon success. The global variable
gdbm_errno will be set upon failure.
For instance, to set a database to use a cache of 10, after opening it with
gdbm_open, but prior to accessing it in any way, the following code
could be used:
int value = 10;
ret = gdbm_setopt( dbf, GDBM_CACHESIZE, &value, sizeof(int));
If the database was opened with the
GDBM_NOLOCK flag, the user may wish
to perform their own file locking on the database file in order to prevent
multiple writers operating on the same file simultaneously.
In order to support this, the
gdbm_fdesc routine is provided.
ret = gdbm_fdesc ( dbf )
Where
dbf is the return value from a previous call to
gdbm_open.
The return value will be the file descriptor of the database.
The following two external variables may be useful:
gdbm_errno is the variable that contains more information about gdbm
errors. (gdbm.h has the definitions of the error values and defines gdbm_errno
as an external variable.)
gdbm_version is the string containing the version information.
There are a few more things of interest. First,
gdbm files are not
"sparse". You can copy them with the UNIX
cp(1) command and
they will not expand in the copying process. Also, there is a compatibility
mode for use with programs that already use UNIX
dbm. In this
compatibility mode, no gdbm file pointer is required by the programmer, and
only one file may be opened at a time. All users in compatibility mode are
assumed to be writers. If the
gdbm file is a read only, it will fail as
a writer, but will also try to open it as a reader. All returned pointers in
datum structures point to data that
gdbm WILL free. They should be
treated as static pointers (as standard UNIX
dbm does).
LINKING¶
This library is accessed by specifying
-lgdbm as the last parameter to
the compile line, e.g.:
gcc -o prog prog.c -lgdbm
If you wish to use the
dbm or
ndbm compatibility routines, you
must link in the
gdbm_compat library as well. For example:
gcc -o prog proc.c -lgdbm -lgdbm_compat
BUGS¶
SEE ALSO¶
dbm, ndbm
AUTHOR¶
by Philip A. Nelson and Jason Downs. Copyright (C) 1990 - 1999 Free Software
Foundation, Inc.
GDBM is free software; you can redistribute it and/or modify it under the terms
of the GNU General Public License as published by the Free Software
Foundation; either version 1, or (at your option) any later version.
GDBM is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
GDBM; see the file COPYING. If not, write to the Free Software Foundation, 675
Mass Ave, Cambridge, MA 02139, USA.
You may contact the original author by:
e-mail: phil@cs.wwu.edu
us-mail: Philip A. Nelson
Computer Science Department
Western Washington University
Bellingham, WA 98226
You may contact the current maintainer by:
e-mail: downsj@downsj.com