gdbm (3) - Linux Manuals
gdbm: The GNU database manager. Includes dbm and ndbm
NAME
GDBM - The GNU database manager. Includes dbm and ndbm compatability. (Version 1.9.)
SYNOPSIS
#include <gdbm.h> extern gdbm_error gdbm_errno;
extern char *gdbm_version;
GDBM_FILE gdbm_open (const char *name, int block_size,
int flags, int mode,
void (*fatal_func)(const char *));
void gdbm_close (GDBM_FILE dbf);
int gdbm_store (GDBM_FILE dbf, datum key, datum content, int flag);
datum gdbm_fetch (GDBM_FILE dbf, datum key);
int gdbm_delete (GDBM_FILE dbf, datum key);
datum gdbm_firstkey (GDBM_FILE dbf);
datum gdbm_nextkey (GDBM_FILE dbf, datum key);
int gdbm_reorganize (GDBM_FILE dbf);
void gdbm_sync (GDBM_FILE dbf);
int gdbm_exists (GDBM_FILE dbf, datum key);
const char *gdbm_strerror (gdbm_error errno);
int gdbm_setopt (GDBM_FILE dbf, int option, int value, int size);
int gdbm_fdesc (GDBM_FILE dbf);
DBM Compatability routines:
#include <dbm.h>
int dbminit (const char *name);
int store (datum key, datum content);
datum fetch (datum key);
int delete (datum key);
datum firstkey (void);
datum nextkey (datum key);
int dbmclose (void);
NDBM Compatability routines:
#include <ndbm.h>
DBM *dbm_open (const char *name, int flags, int mode);
void dbm_close (DBM *file);
datumdbm_fetch(DBM* file ,datum key );
int dbm_store (DBM *file, datum key, datum content, int flags);
int dbm_delete (DBM *file, datum key);
datum dbm_firstkey (DBM *file);
datum dbm_nextkey (DBM *file, datum key);
int dbm_error (DBM *file);
int dbm_clearerr (DBM *file);
int dbm_pagfno (DBM *file);
int dbm_dirfno (DBM *file);
int dbm_rdonly (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.This manpage is a short description of the GDBM library. For a detailed discussion, including examples of the configuration and usage recommendations, refer to the GDBM Manual available in Texinfo format. To access it, run:
Should any discrepancies occur between this manpage and the
GDBM Manual, the later shall be considered the authoritative
source.
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 gdbm_open (const char *name, int block_size,
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:
The GDBM_NOMMAP added to read_write by bitwise or instructs
gdbm_open to disable the use of
mmap(2).
For the last three (writers of the database) the following may be added
added to read_write by bitwise or:
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 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:
void gdbm_close (GDBM_FILE dbf);
The database is used by 3 primary routines. The first stores data in the
database.
int gdbm_store (GDBM_FILE dbf, datum key, datum content, int 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:
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 in dbm or ndbm. Your data
can be as large as you want.
To search for some data, use:
datum gdbm_fetch (GDBM_FILE dbf, datum 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(3). 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:
int gdbm_exists (GDBM_FILE dbf, datum 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
will be true. If nothing appropiate is found, false is returned.
This routine is useful for checking for the existence of a record,
without performing the memory allocation done by gdbm_fetch.
To remove some data from the database:
int gdbm_delete (GDBM_FILE dbf, datum 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.)
datum gdbm_firstkey (GDBM_FILE dbf);
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(3)
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:
The following routine should be used very infrequently.
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.
void gdbm_sync (GDBM_FILE 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:
const char *gdbm_strerror (gdbm_error errno);
Gdbm now supports the ability to set certain options on an
already open database.
int gdbm_setopt (GDBM_FILE dbf, int option, int value, int 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:
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:
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.
int gdbm_fdesc (GDBM_FILE 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).
If you wish to use the dbm or ndbm compatibility routines,
you must link in the gdbm_compat library as well. For example:
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. If not, see <http://gnu.org/licenses/gpl.html>
You may contact the current maintainers by:
datum gdbm_nextkey (GDBM_FILE dbf, datum key);
key = gdbm_firstkey (dbf);
while (key.dptr)
{
nextkey = gdbm_nextkey (dbf, key);
if (some condition)
gdbm_delete ( dbf, key );
free (key.dptr);
key = nextkey;
}
int value = 10;
ret = gdbm_setopt( dbf, GDBM_CACHESIZE, &value, sizeof(int));
LINKING
This library is accessed by specifying -lgdbm as the last
parameter to the compile line, e.g.:
gcc -o prog prog.c -lgdbm
gcc -o prog proc.c -lgdbm -lgdbm_compat
BUG REPORTS
Send bug reports to <bug-gdbm [at] gnu.org>.
AUTHOR
by Philip A. Nelson, Jason Downs and Sergey Poznyakoff.
COPYRIGHT
Copyright © 1990 - 2011 Free Software Foundation, Inc.
CONTACTS
You may contact the original author by:
e-mail:
Computer Science Department
Western Washington University
Bellingham, WA 98226
e-mail:
and
e-mail: