NAME

BerkeleyDB - Perl extension for Berkeley DB version 2

SYNOPSIS

use BerkeleyDB;

$env = new BerkeleyDB::Env [OPTIONS] ;

$db  = tie %hash, 'BerkeleyDB::Hash', [OPTIONS] ;
$db  = new BerkeleyDB::Hash [OPTIONS] ;

$db  = tie %hash, 'BerkeleyDB::Btree', [OPTIONS] ;
$db  = new BerkeleyDB::Btree [OPTIONS] ;

$db  = tie %hash, 'BerkeleyDB::Recno', [OPTIONS] ;
$db  = new BerkeleyDB::Recno [OPTIONS] ;

$db  = new BerkeleyDB::Unknown [OPTIONS] ;

$hash{$key} = $value ;
$value = $hash{$key} ;
each %hash ;
keys %hash ;
values %hash ;

$status = $db->db_get()
$status = $db->db_put() ;
$status = $db->db_del() ;
$status = $db->db_sync() ;
$status = $db->db_close() ;
$hash_ref = $db->db_stat() ;
$type = $db->type() ;
$type = $db->status() ;
$type = $db->byteswapped() ;

($flag, $old_offset, $old_length) = $db->partial_set($offset, $length) ;
($flag, $old_offset, $old_length) = $db->partial_clear() ;

$cursor = $db->db_cursor([$flags]) ;
$status = $cursor->c_get() ;
$status = $cursor->c_put() ;
$status = $cursor->c_del() ;
$status = $cursor->status() ;
$status = $cursor->c_close() ;

$cursor = $db->db_join() ;
$status = $cursor->c_get() ;
$status = $cursor->c_close() ;

$status = $env->txn_checkpoint()
$hash_ref = $env->txn_stat()

$txn = $env->txn_begin() ;
$status = $txn->txn_prepare()
$status = $txn->txn_commit()
$status = $txn->txn_abort()
$status = $txn->txn_id()

$BerkeleyDB::Error
$BerkeleyDB::db_version

# DBM Filters
$old_filter = $db->filter_store_key  ( sub { ... } ) ;
$old_filter = $db->filter_store_value( sub { ... } ) ;
$old_filter = $db->filter_fetch_key  ( sub { ... } ) ;
$old_filter = $db->filter_fetch_value( sub { ... } ) ;

# deprecated, but supported
$txn_mgr = $env->TxnMgr();
$status = $txn_mgr->txn_checkpoint()
$hash_ref = $txn_mgr->txn_stat()
$txn = $txn_mgr->txn_begin() ;

DESCRIPTION

NOTE: This document is still under construction. Expect it to be incomplete in places.

This Perl module provides an interface to most of the functionality available in Berkeley DB version 2. In general it is safe to assume that the interface provided here to be identical to the Berkeley DB interface. The main changes have been to make the Berkeley DB API work in a Perl way.

The reader is expected to be familiar with the Berkeley DB documentation. Where the interface provided here is identical to the Berkeley DB library and the

The db_appinit, db_cursor, db_open and db_txn man pages are particularly relevant.

The interface to Berkeley DB is implemented with a number of Perl classes.

ENV CLASS

The BerkeleyDB::Env class provides an interface to the Berkeley DB function db_appinit. Its purpose is to initialise a number of sub-systems that can then be used in a consistent way in all the databases you make use of the environment.

If you don't intend using transactions, locking or logging, then you shouldn't need to make use of BerkeleyDB::Env.

Synopsis

$env = new BerkeleyDB::Env
         [ -Home         => $path, ]
         [ -Config       => { name => value, name => value }, ]
         [ -ErrFile      => filename or filehandle, ]
         [ -ErrPrefix    => "string", ]
         [ -Flags        => number, ]
         [ -Verbose      => boolean, ]

All the parameters to the BerkeleyDB::Env constructor are optional.

-Home

If present, this parameter should point to an existing directory. Any files that aren't specified with an absolute path in the sub-systems that are initialised by the BerkeleyDB::Env class will be assumed to live in the Home directory.

For example, in the code fragment below the database "fred.db" will be opened in the directory "/home/databases" because it was specified as a relative path, but "joe.db" will be opened in "/other" because it was part of an absolute path.

    $env = new BerkeleyDB::Env
             -Home         => "/home/databases"
    ...

    $db1 = new BerkeleyDB::Hash
	     -Filename = "fred.db",
	     -Env => $env
    ...

    $db2 = new BerkeleyDB::Hash
	     -Filename = "/other/joe.db",
	     -Env => $env
    ...

-Config

This is a variation on the -Home parameter, but it allows finer control of where specific types of files will be stored.

The parameter expects a reference to a hash. Valid keys are: DB_DATA_DIR, DB_LOG_DIR and DB_TMP_DIR

The code below shows an example of how it can be used.

$env = new BerkeleyDB::Env
         -Config => { DB_DATA_DIR => "/home/databases",
                      DB_LOG_DIR  => "/home/logs",
                      DB_TMP_DIR  => "/home/tmp"
                    }
...

-ErrFile

Expects either the name of a file or a reference to a filehandle. Any errors generated internally by Berkeley DB will be logged to this file.

-ErrPrefix

Allows a prefix to be added to the error messages before they are sent to -ErrFile.

-Flags

The Flags parameter specifies both which sub-systems to initialise, as well as a number of environment-wide options. See the Berkeley DB documentation for more details of these options.

Any of the following can be specified by OR'ing them:

DB_CREATE

If any of the files specified do not already exist, create them.

DB_INIT_CDB

Initialise the Concurrent Access Methods

DB_INIT_LOCK

Initialise the Locking sub-system.

DB_INIT_LOG

Initialise the Logging sub-system.

DB_INIT_MPOOL

Initialise the ...

DB_INIT_TXN

Initialise the ...

DB_MPOOL_PRIVATE

Initialise the ...

DB_INIT_MPOOL is also specified.

Initialise the ...

DB_NOMMAP

Initialise the ...

DB_RECOVER

DB_RECOVER_FATAL

DB_THREAD

DB_TXN_NOSYNC

DB_USE_ENVIRON

DB_USE_ENVIRON_ROOT

-Verbose

Add extra dubugging information to the messages sent to -ErrFile.

Methods

The environment class has the following methods:

$env->errPrefix("string") ;

This method is identical to the -ErrPrefix flag. It allows the error prefix string to be changed dynamically.

$txn = $env->TxnMgr()

Constructor for creating a TxnMgr object. See "TRANSACTIONS" for more details of using transactions.

This method is deprecated.

$env->txn_begin()

TODO

$env->txn_stat()

TODO

$env->txn_checkpoint()

TODO

$env->status()

Returns the status of the last BerkeleyDB::Env method.

Examples

TODO.

THE DATABASE CLASSES

BerkeleyDB supports the following database formats:

BerkeleyDB::Hash

This database type allows arbitrary key/value pairs to be stored in data files. This is equivalent to the functionality provided by other hashing packages like DBM, NDBM, ODBM, GDBM, and SDBM. Remember though, the files created using BerkeleyDB::Hash are not compatible with any of the other packages mentioned.

A default hashing algorithm, which will be adequate for most applications, is built into BerkeleyDB. If you do need to use your own hashing algorithm it is possible to write your own in Perl and have BerkeleyDB use it instead.

BerkeleyDB::Btree

The Btree format allows arbitrary key/value pairs to be stored in a B+tree.

As with the BerkeleyDB::Hash format, it is possible to provide a user defined Perl routine to perform the comparison of keys. By default, though, the keys are stored in lexical order.

BerkeleyDB::Recno

TODO.

BerkeleyDB::Unknown

This isn't a database format at all. It is used when you want to open an existing Berkeley DB database without having to know what type is it.

Each of the database formats described above is accessed via a corresponding BerkeleyDB class. These will be described in turn in the next sections.

BerkeleyDB::Hash

The equivalent of db_open with type DB_HASH. Two forms of constructor are supported:

$db = new BerkeleyDB::Hash
            [ -Filename      => "filename", ]
            [ -Flags         => flags,]
            [ -Property      => flags,]
            [ -Mode          => number,]
            [ -Cachesize     => number,]
            [ -Lorder        => number,]
            [ -Pagesize      => number,]
            [ -Env           => $env,]
            [ -Txn           => $txn,]
            # BerkeleyDB::Hash specific
            [ -Ffactor       => number,]
            [ -Nelem         => number,]
            [ -Hash          => code reference,]
            [ -DupCompare    => code reference,]

and this

[$db =] tie %hash, 'BerkeleyDB::Hash', 
            [ -Filename      => "filename", ]
            [ -Flags         => flags,]
            [ -Property      => flags,]
            [ -Mode          => number,]
            [ -Cachesize     => number,]
            [ -Lorder        => number,]
            [ -Pagesize      => number,]
            [ -Env           => $env,]
            [ -Txn           => $txn,]
            # BerkeleyDB::Hash specific
            [ -Ffactor       => number,]
            [ -Nelem         => number,]
            [ -Hash          => code reference,]
            [ -DupCompare    => code reference,]

When the "tie" interface is used, reading from and writing to the database is achieved via the tied hash. In this case the database operates like a Perl associative array that happens to be stored on disk.

In addition to the high-level tied hash interface, it is possible to make use of the underlying methods provided by Berkeley DB

Options

In addition to the standard set of options (see "COMMON OPTIONS") BerkeleyDB::Hash supports these options:

-Property

Used to specify extra flags when opening a database. The following flags may be specified by logically OR'ing together one or more of the following values:

DB_DUP

When creating a new database, this flag enables the storing of duplicate keys in the database. If DB_DUPSORT is not specified as well, the duplicates are stored in the order they are created in the database.

DB_DUPSORT

Enables the sorting of duplicate keys in the database. Ignored if DB_DUP isn't also specified.

-Ffactor

-Nelem

See the Berkeley DB documentation for details of these options.

-Hash

Allows you to provide a user defined hash function. If not specified, a default hash function is used. Here is a template for a user-defined hash function

    sub hash
    {
        my ($data) = shift ;
        ...
        # return the hash value for $data
	return $hash ;
    }

    tie %h, "BerkeleyDB::Hash", 
        -Filename => $filename, 
    	-Hash     => \&hash,
	...

See "" for an example.

-DupCompare

Used in conjunction with the DB_DUPOSRT flag.

    sub compare
    {
	my ($key, $key2) = @_ ;
        ...
        # return  0 if $key1 eq $key2
        #        -1 if $key1 lt $key2
        #         1 if $key1 gt $key2
        return (-1 , 0 or 1) ;
    }

    tie %h, "BerkeleyDB::Hash", 
        -Filename   => $filename, 
    	-DupCompare => \&compare,
	...

Methods

BerkeleyDB::Hash only supports the standard database methods. See "COMMON DATABASE METHODS".

A Simple Tied Hash Example

    use strict ;
    use BerkeleyDB ;
    use vars qw( %h $k $v ) ;

    my $filename = "fruit" ;
    unlink $filename ;
    tie %h, "BerkeleyDB::Hash",
                -Filename => $filename,
		-Flags    => DB_CREATE
        or die "Cannot open file $filename: $! $BerkeleyDB::Error\n" ;

    # Add a few key/value pairs to the file
    $h{"apple"} = "red" ;
    $h{"orange"} = "orange" ;
    $h{"banana"} = "yellow" ;
    $h{"tomato"} = "red" ;

    # Check for existence of a key
    print "Banana Exists\n\n" if $h{"banana"} ;

    # Delete a key/value pair.
    delete $h{"apple"} ;

    # print the contents of the file
    while (($k, $v) = each %h)
      { print "$k -> $v\n" }

    untie %h ;

here is the output:

Banana Exists

orange -> orange
tomato -> red
banana -> yellow

Note that the like ordinary associative arrays, the order of the keys retrieved from a Hash database are in an apparently random order.

Another Simple Hash Example

Do the same as the previous example but not using tie.

    use strict ;
    use BerkeleyDB ;

    my $filename = "fruit" ;
    unlink $filename ;
    my $db = new BerkeleyDB::Hash
                -Filename => $filename,
		-Flags    => DB_CREATE
        or die "Cannot open file $filename: $! $BerkeleyDB::Error\n" ;

    # Add a few key/value pairs to the file
    $db->db_put("apple", "red") ;
    $db->db_put("orange", "orange") ;
    $db->db_put("banana", "yellow") ;
    $db->db_put("tomato", "red") ;

    # Check for existence of a key
    print "Banana Exists\n\n" if $db->db_get("banana", $v) == 0;

    # Delete a key/value pair.
    $db->db_del("apple") ;

    # print the contents of the file
    my ($k, $v) = ("", "") ;
    my $cursor = $db->db_cursor() ;
    while ($cursor->c_get($k, $v, DB_NEXT) == 0)
      { print "$k -> $v\n" }

    undef $cursor ;
    undef $db ;

Changing the hash

Duplicate keys

invert the fruit/colour hash

Sorting Duplicate Keys

BerkeleyDB::Btree

The equivalent of db_open with type DB_BTREE. Two forms of constructor are supported:

$db = new BerkeleyDB::Btree
            [ -Filename      => "filename", ]
            [ -Flags         => flags,]
            [ -Property      => flags,]
            [ -Mode          => number,]
            [ -Cachesize     => number,]
            [ -Lorder        => number,]
            [ -Pagesize      => number,]
            [ -Env           => $env,]
            [ -Txn           => $txn,]
            # BerkeleyDB::Btree specific
            [ -Minkey        => number,]
            [ -Compare       => code reference,]
            [ -DupCompare    => code reference,]
            [ -Prefix        => code reference,]

and this

[$db =] tie %hash, 'BerkeleyDB::Btree', 
            [ -Filename      => "filename", ]
            [ -Flags         => flags,]
            [ -Property      => flags,]
            [ -Mode          => number,]
            [ -Cachesize     => number,]
            [ -Lorder        => number,]
            [ -Pagesize      => number,]
            [ -Env           => $env,]
            [ -Txn           => $txn,]
            # BerkeleyDB::Btree specific
            [ -Minkey        => number,]
            [ -Compare       => code reference,]
            [ -DupCompare    => code reference,]
            [ -Prefix        => code reference,]

Options

In addition to the standard set of options (see "COMMON OPTIONS") BerkeleyDB::Btree supports these options:

-Property

Used to specify extra flags when opening a database. The following flags may be specified by logically OR'ing together one or more of the following values:

DB_DUP

DB_DUPSORT

Enables the sorting of duplicate keys in the database. Ignored if DB_DUP isn't also specified.

Minkey

Compare

Allow you to override the default sort order used in the database. See "Changing the sort order" for an example.

    sub compare
    {
	my ($key, $key2) = @_ ;
        ...
        # return  0 if $key1 eq $key2
        #        -1 if $key1 lt $key2
        #         1 if $key1 gt $key2
        return (-1 , 0 or 1) ;
    }

    tie %h, "BerkeleyDB::Hash", 
        -Filename   => $filename, 
    	-Compare    => \&compare,
	...

Prefix

    sub prefix
    {
	my ($key, $key2) = @_ ;
        ...
        # return number of bytes of $key2 which are 
        # necessary to determine that it is greater than $key1
        return $bytes ;
    }

    tie %h, "BerkeleyDB::Hash", 
        -Filename   => $filename, 
    	-Prefix     => \&prefix,
	...
=item DupCompare

    sub compare
    {
	my ($key, $key2) = @_ ;
        ...
        # return  0 if $key1 eq $key2
        #        -1 if $key1 lt $key2
        #         1 if $key1 gt $key2
        return (-1 , 0 or 1) ;
    }

    tie %h, "BerkeleyDB::Hash", 
        -Filename   => $filename, 
    	-DupCompare => \&compare,
	...

Methods

See "COMMON DATABASE METHODS".

Apart from the standard Methods, BerkeleyDB::Btree supports one extra method:

$ref = $db->db_stat(): Returns a reference to an associative array containing information about the database.

A Btree Example

Changing the sort order

This script shows how to override the default sorting algorithm that BerkeleyDB::Btree uses. Instead of using the normal lexical ordering, a case insensitive compare function will be used.

    use strict ;
    use BerkeleyDB ;

    my $filename = "tree" ;
    unlink $filename ;
    my %h ;
    tie %h, 'BerkeleyDB::Btree',
    		-Filename   => $filename,
	        -Flags      => DB_CREATE,
		-Compare    => sub { lc $_[0] cmp lc $_[1] }
      or die "Cannot open $filename: $!\n" ;

    # Add a key/value pair to the file
    $h{'Wall'} = 'Larry' ;
    $h{'Smith'} = 'John' ;
    $h{'mouse'} = 'mickey' ;
    $h{'duck'}  = 'donald' ;

    # Delete
    delete $h{"duck"} ;

    # Cycle through the keys printing them in order.
    # Note it is not necessary to sort the keys as
    # the btree will have kept them in order automatically.
    foreach (keys %h)
      { print "$_\n" }

    untie %h ;

Here is the output from the code above.

mouse
Smith
Wall

There are a few point to bear in mind if you want to change the ordering in a BTREE database:

The new compare function must be specified when you create the database.
You cannot change the ordering once the database has been created. Thus you must use the same compare function every time you access the database.

Using db_stat

BerkeleyDB::Recno

The equivalent of db_open with type DB_RECNO. Two forms of constructor are supported:

$db = new BerkeleyDB::Recno
            [ -Filename      => "filename", ]
            [ -Flags         => flags,]
            [ -Property      => flags,]
            [ -Mode          => number,]
            [ -Cachesize     => number,]
            [ -Lorder        => number,]
            [ -Pagesize      => number,]
            [ -Env           => $env,]
            [ -Txn           => $txn,]
            # BerkeleyDB::Recno specific
            [ -Delim           => byte,]
            [ -Len             => number,]
            [ -Pad             => byte,]
            [ -Source          => filename,]

and this

[$db =] tie @arry, 'BerkeleyDB::Recno', 
            [ -Filename      => "filename", ]
            [ -Flags         => flags,]
            [ -Property      => flags,]
            [ -Mode          => number,]
            [ -Cachesize     => number,]
            [ -Lorder        => number,]
            [ -Pagesize      => number,]
            [ -Env           => $env,]
            [ -Txn           => $txn,]
            # BerkeleyDB::Recno specific
            [ -Delim           => byte,]
            [ -Len             => number,]
            [ -Pad             => byte,]
            [ -Source          => filename,]

A Recno Example

Here is a simple example that uses RECNO (if you are using a version of Perl earlier than 5.004_57 this example won't work -- see "Extra RECNO Methods" for a workaround).

    use strict ;
    use BerkeleyDB ;

    my $filename = "text" ;
    unlink $filename ;

    my @h ;
    tie @h, 'BerkeleyDB::Recno',
    		-Filename   => $filename,
	        -Flags      => DB_CREATE,
		-Property   => DB_RENUMBER
      or die "Cannot open $filename: $!\n" ;

    # Add a few key/value pairs to the file
    $h[0] = "orange" ;
    $h[1] = "blue" ;
    $h[2] = "yellow" ;

    push @h, "green", "black" ;

    my $elements = scalar @h ;
    print "The array contains $elements entries\n" ;

    my $last = pop @h ;
    print "popped $last\n" ;

    unshift @h, "white" ;
    my $first = shift @h ;
    print "shifted $first\n" ;

    # Check for existence of a key
    print "Element 1 Exists with value $h[1]\n" if $h[1] ;

    untie @h ;

Here is the output from the script:

The array contains 5 entries
popped black
shifted white
Element 1 Exists with value blue
The last element is green
The 2nd last element is yellow

BerkeleyDB::Unknown

This class is used to open an existing database.

The equivalent of db_open with type DB_UNKNOWN. The constructor takes looks like this:

$db = new BerkeleyDB::Unknown
            [ -Filename      => "filename", ]
            [ -Flags         => flags,]
            [ -Property      => flags,]
            [ -Mode          => number,]
            [ -Cachesize     => number,]
            [ -Lorder        => number,]
            [ -Pagesize      => number,]
            [ -Env           => $env,]
            [ -Txn           => $txn,]

An example

COMMON OPTIONS

All database access class constructors support the common set of options defined below. All are optional.

-Filename

The database filename. If no filename is specified, a temporary file will be created and removed once the program terminates.

-Flags

Specify how the database will be opened/created. The valid flags are:

DB_CREATE

Create any underlying files, as necessary. If the files do not already exist and the DB_CREATE flag is not specified, the call will fail.

DB_NOMMAP

Not supported by BerkeleyDB.

DB_RDONLY

Opens the database in read-only mode.

DB_THREAD

Not supported by BerkeleyDB.

DB_TRUNCATE

If the database file already exists, remove all the data before opening it.

-Mode

Determines the file protection when the database is created. Defaults to 0666.

-Cachesize

-Lorder

-Pagesize

-Env

When working under a Berkeley DB environment, this parameter

Defaults to no environment.

-Txn

TODO.

COMMON DATABASE METHODS

All the database interfaces support the common set of methods defined below.

All the methods below return 0 to indicate success.

$status = $db->db_get($key, $value [, $flags])

Given a key ($key) this method reads the value associated with it from the database. If it exists, the value read from the database is returned in the $value parameter.

The $flags parameter is optional. If present, it must be set to one of the following values:

DB_GET_BOTH: When the DB_GET_BOTH flag is specified, db_get checks for the existence of both the $key and $value in the database.
DB_SET_RECNO: TODO.

In addition, the following value may be set by logically OR'ing it into the $flags parameter:

DB_RMW: TODO

$status = $db->db_put($key, $value [, $flags])

Stores a key/value pair in the database.

The $flags parameter is optional. If present it must be set to one of the following values:

DB_APPEND

This flag is only applicable when accessing a BerkeleyDB::Recno database.

TODO.

DB_NOOVERWRITE

If this flag is specified and $key already exists in the database, the call to db_put will return DB_KEYEXIST.

$status = $db->db_del($key [, $flags])

Deletes a key/value pair in the database associated with $key. If duplicate keys are enabled in the database, db_del will delete all key/value pairs with key $key.

The $flags parameter is optional and is currently unused.

$status = $db->db_sync()

If any parts of the database are in memory, write them to the database.

$cursor = $db->db_cursor([$flags])

Creates a cursor object. This is used to access the contents of the database sequentially. See CURSORS for details of the methods available when working with cursors.

The $flags parameter is optional. If present it must be set to one of the following values:

DB_RMW: TODO.

($flag, $old_offset, $old_length) = $db->partial_set($offset, $length) ;

TODO

($flag, $old_offset, $old_length) = $db->partial_clear() ;

TODO

$db->byteswapped()

TODO

$db->type()

Returns the type of the database. The possible return code are DB_HASH for a BerkeleyDB::Hash database, DB_BTREE for a BerkeleyDB::Btree database and DB_RECNO for a BerkeleyDB::Recno database. This method is typically used when a database has been opened with BerkeleyDB::Unknown.

$status = $db->status()

Returns the status of the last $db method called.

CURSORS

A cursor is used whenever you want to access the contents of a database in sequential order. A cursor object is created with the db_cursor

A cursor object has the following methods available:

$status = $cursor->c_get($key, $value, $flags)

Reads a key/value pair from the database, returning the data in $key and $value. The key/value pair actually read is controlled by the $flags parameter, which can take one of the following values:

DB_FIRST

Set the cursor to point to the first key/value pair in the database. Return the key/value pair in $key and $value.

DB_LAST

Set the cursor to point to the last key/value pair in the database. Return the key/value pair in $key and $value.

DB_NEXT

If the cursor is already pointing to a key/value pair, it will be incremented to point to the next key/value pair and return its contents.

If the cursor isn't initialised, DB_NEXT works just like DB_FIRST.

If the cursor is already positioned at the last key/value pair, c_get will return DB_NOTFOUND.

DB_NEXT_DUP

This flag is only valid when duplicate keys have been enabled in a database. If the cursor is already pointing to a key/value pair and the key of the next key/value pair is identical, the cursor will be incremented to point to it and their contents returned.

DB_PREV

If the cursor is already pointing to a key/value pair, it will be decremented to point to the previous key/value pair and return its contents.

If the cursor isn't initialised, DB_PREV works just like DB_LAST.

If the cursor is already positioned at the first key/value pair, c_get will return DB_NOTFOUND.

DB_CURRENT

If the cursor has been set to point to a key/value pair, return their contents. If the key/value pair referenced by the cursor has been deleted, c_get will return DB_KEYEMPTY.

DB_SET

Set the cursor to point to the key/value pair referenced by $key and return the value in $value.

DB_SET_RANGE

This flag is a variation on the DB_SET flag. As well as returning the value, it also returns the key, via $key. When used with a BerkeleyDB::Btree database the key matched by c_get will be the shortest key (in length) which is greater than or equal to the key supplied, via $key. This allows partial key searches. See ??? for an example of how to use this flag.

DB_GET_BOTH

Another variation on DB_SET. This one returns both the key and the value.

DB_SET_RECNO

TODO.

DB_GET_RECNO

TODO.

In addition, the following value may be set by logically OR'ing it into the $flags parameter:

DB_RMW: TODO.

$status = $cursor->c_put($key, $value, $flags)

Stores the key/value pair in the database. The position that the data is stored in the database is controlled by the $flags parameter, which must take one of the following values:

DB_AFTER

When used with a Btree or Hash database, a duplicate of the key referenced by the current cursor position will be created and the contents of $value will be associated with it - $key is ignored. The new key/value pair will be stored immediately after the current cursor position. Obviously the database has to have been opened with DB_DUP.

When used with a Recno ... TODO

DB_BEFORE

When used with a Btree or Hash database, a duplicate of the key referenced by the current cursor position will be created and the contents of $value will be associated with it - $key is ignored. The new key/value pair will be stored immediately before the current cursor position. Obviously the database has to have been opened with DB_DUP.

When used with a Recno ... TODO

DB_CURRENT

If the cursor has been initialised, replace the value of the key/value pair stored in the database with the contents of $value.

DB_KEYFIRST

Only valid with a Btree or Hash database. This flag is only really used when duplicates are enabled in the database and sorted duplicates haven't been specified. In this case the key/value pair will be inserted as the first entry in the duplicates for the particular key.

DB_KEYLAST

Only valid with a Btree or Hash database. This flag is only really used when duplicates are enabled in the database and sorted duplicates haven't been specified. In this case the key/value pair will be inserted as the last entry in the duplicates for the particular key.

$status = $cursor->c_del([$flags])

This method deletes the key/value pair associated with the current cursor position. The cursor position will not be changed by this operation, so any subsequent cursor operation must first initialise the cursor to point to a valid key/value pair.

If the key/value pair associated with the cursor have already been deleted, c_del will return DB_KEYEMPTY.

The $flags parameter is not used at present.

$status = $cursor->status()

Returns the status of the last cursor method as a dual type.

Cursor Examples

Iterating from first to last, then in reverse.

examples of each of the flags.

JOIN

Join support for BerkeleyDB is in progress. Watch this space.

DBM Filters

A DBM Filter is a piece of code that is be used when you always want to make the same transformation to all keys and/or values in a DBM database. All of the database classes (BerkeleyDB::Hash, BerkeleyDB::Btree and BerkeleyDB::Recno) support DBM Filters.

There are four methods associated with DBM Filters. All work identically, and each is used to install (or uninstall) a single DBM Filter. Each expects a single parameter, namely a reference to a sub. The only difference between them is the place that the filter is installed.

To summarise:

filter_store_key: If a filter has been installed with this method, it will be invoked every time you write a key to a DBM database.
filter_store_value: If a filter has been installed with this method, it will be invoked every time you write a value to a DBM database.
filter_fetch_key: If a filter has been installed with this method, it will be invoked every time you read a key from a DBM database.
filter_fetch_value: If a filter has been installed with this method, it will be invoked every time you read a value from a DBM database.

You can use any combination of the methods, from none, to all four.

All filter methods return the existing filter, if present, or undef in not.

To delete a filter pass undef to it.

The Filter

When each filter is called by Perl, a local copy of $_ will contain the key or value to be filtered. Filtering is achieved by modifying the contents of $_. The return code from the filter is ignored.

An Example -- the NULL termination problem.

Consider the following scenario. You have a DBM database that you need to share with a third-party C application. The C application assumes that all keys and values are NULL terminated. Unfortunately when Perl writes to DBM databases it doesn't use NULL termination, so your Perl application will have to manage NULL termination itself. When you write to the database you will have to use something like this:

$hash{"$key\0"} = "$value\0" ;

Similarly the NULL needs to be taken into account when you are considering the length of existing keys/values.

It would be much better if you could ignore the NULL terminations issue in the main application code and have a mechanism that automatically added the terminating NULL to all keys and values whenever you write to the database and have them removed when you read from the database. As I'm sure you have already guessed, this is a problem that DBM Filters can fix very easily.

    use strict ;
    use BerkeleyDB ;

    my %hash ;
    my $filename = "/tmp/filt" ;
    unlink $filename ;

    my $db = tie %hash, 'BerkeleyDB::Hash',
    		-Filename   => $filename,
	        -Flags      => DB_CREATE
      or die "Cannot open $filename: $!\n" ;

    # Install DBM Filters
    $db->filter_fetch_key  ( sub { s/\0$//    } ) ;
    $db->filter_store_key  ( sub { $_ .= "\0" } ) ;
    $db->filter_fetch_value( sub { s/\0$//    } ) ;
    $db->filter_store_value( sub { $_ .= "\0" } ) ;

    $hash{"abc"} = "def" ;
    my $a = $hash{"ABC"} ;
    # ...
    undef $db ;
    untie %hash ;

Hopefully the contents of each of the filters should be self-explanatory. Both "fetch" filters remove the terminating NULL, and both "store" filters add a terminating NULL.

Another Example -- Key is a C int.

Here is another real-life example. By default, whenever Perl writes to a DBM database it always writes the key and value as strings. So when you use this:

$hash{12345} = "something" ;

the key 12345 will get stored in the DBM database as the 5 byte string "12345". If you actually want the key to be stored in the DBM database as a C int, you will have to use pack when writing, and unpack when reading.

Here is a DBM Filter that does it:

    use strict ;
    use BerkeleyDB ;
    my %hash ;
    my $filename = "/tmp/filt" ;
    unlink $filename ;


    my $db = tie %hash, 'BerkeleyDB::Btree',
    		-Filename   => $filename,
	        -Flags      => DB_CREATE
      or die "Cannot open $filename: $!\n" ;

    $db->filter_fetch_key  ( sub { $_ = unpack("i", $_) } ) ;
    $db->filter_store_key  ( sub { $_ = pack ("i", $_) } ) ;
    $hash{123} = "def" ;
    # ...
    undef $db ;
    untie %hash ;

This time only two filters have been used -- we only need to manipulate the contents of the key, so it wasn't necessary to install any value filters.

TRANSACTIONS

TODO.

Using BerkeleyDB with MLDBM

Both BerkeleyDB::Hash and BerkeleyDB::Btree can be used with the MLDBM module. The code fragment below shows how to open associate MLDBM with BerkeleyDB::Btree. To use BerkeleyDB::Hash just replace BerkeleyDB::Btree with BerkeleyDB::Hash.

   use strict ;
   use BerkeleyDB ;
   use MLDBM qw(BerkeleyDB::Btree) ;
   use Data::Dumper;

   my $filename = 'testmldbm' ;
   my %o ;
    
   unlink $filename ;
   tie %o, MLDBM, -Filename => $filename,
                  -Flags    => DB_CREATE
                   or die "Cannot open database '$filename: $!\n";

See the MLDNM documentation for information on how to use the module and for details of its limitations.

EXAMPLES

TODO.

HINTS & TIPS

TODO

The untie Gotcha

TODO

COMMON QUESTIONS

This section answers some of the questions that have arisen

TODO

Relationship with DB_File

TODO

How do I store Perl data structures with BerkeleyDB?

See "Using BerkeleyDB with MLDBM".

HISTORY

See the Changes file.

AVAILABILITY

The most recent version of BerkeleyDB can always be found on CPAN (see "CPAN" in perlmod for details), in the directory modules/by-module/BerkeleyDB.

The official web site for Berkeley DB is http://www.sleepycat.com.

COPYRIGHT

Although BerkeleyDB is covered by the Perl license, the library it makes use of, namely Berkeley DB, is not. Berkeley DB has its own copyright and its own license. Please take the time to read it.

Here are are few words taken from the Berkeley DB FAQ (at http://www.sleepycat.com) regarding the license:

Do I have to license DB to use it in Perl scripts?

No. The Berkeley DB license requires that software that uses
Berkeley DB be freely redistributable. In the case of Perl, that
software is Perl, and not your scripts. Any Perl scripts that you
write are your property, including scripts that make use of Berkeley
DB. Neither the Perl license nor the Berkeley DB license
place any restriction on what you may do with them.

If you are in any doubt about the license situation, contact either the Berkeley DB authors or the author of BerkeleyDB. See "AUTHOR" for details.

AUTHOR

Paul Marquess <Paul.Marquess@btinternet.com>.

Questions about Berkeley DB may be addressed to <db@sleepycat.com>.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)

NAME

SYNOPSIS

DESCRIPTION

ENV CLASS

Synopsis

Methods

Examples

THE DATABASE CLASSES

BerkeleyDB::Hash

Options

Methods

A Simple Tied Hash Example

Another Simple Hash Example

Changing the hash

Duplicate keys

Sorting Duplicate Keys

BerkeleyDB::Btree

Options

Methods

A Btree Example

Changing the sort order

Using db_stat

BerkeleyDB::Recno

A Recno Example

BerkeleyDB::Unknown

An example

COMMON OPTIONS

COMMON DATABASE METHODS

$status = $db->db_get($key, $value [, $flags])

$status = $db->db_put($key, $value [, $flags])

$status = $db->db_del($key [, $flags])

$status = $db->db_sync()

$cursor = $db->db_cursor([$flags])

($flag, $old_offset, $old_length) = $db->partial_set($offset, $length) ;

($flag, $old_offset, $old_length) = $db->partial_clear() ;

$db->byteswapped()

$db->type()

$status = $db->status()

CURSORS

$status = $cursor->c_get($key, $value, $flags)

$status = $cursor->c_put($key, $value, $flags)

$status = $cursor->c_del([$flags])

$status = $cursor->status()

Cursor Examples

JOIN

DBM Filters

The Filter

An Example -- the NULL termination problem.

Another Example -- Key is a C int.

TRANSACTIONS

Using BerkeleyDB with MLDBM

EXAMPLES

HINTS & TIPS

Sharing Databases With C Applications

The untie Gotcha

COMMON QUESTIONS

Relationship with DB_File

How do I store Perl data structures with BerkeleyDB?

HISTORY

AVAILABILITY

COPYRIGHT

AUTHOR

SEE ALSO

Module Install Instructions