|
BerkeleyDB - Perl extension for Berkeley DB version 2, 3 or 4 |
db_sync()db_cursor([$flags])partial_clear() ;byteswapped()type()status()truncate($count)c_dup($flags)c_del([$flags])status()
BerkeleyDB - Perl extension for Berkeley DB version 2, 3 or 4
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 = tie %hash, 'BerkeleyDB::Queue', [OPTIONS] ; $db = new BerkeleyDB::Queue [OPTIONS] ;
$db = new BerkeleyDB::Unknown [OPTIONS] ;
$status = BerkeleyDB::db_remove [OPTIONS] $status = BerkeleyDB::db_rename [OPTIONS] $status = BerkeleyDB::db_verify [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() ; $status = $db->db_close() ; $status = $db->db_pget() $hash_ref = $db->db_stat() ; $status = $db->db_key_range(); $type = $db->type() ; $status = $db->status() ; $boolean = $db->byteswapped() ; $status = $db->truncate($count) ;
($flag, $old_offset, $old_length) = $db->partial_set($offset, $length) ; ($flag, $old_offset, $old_length) = $db->partial_clear() ;
$cursor = $db->db_cursor([$flags]) ; $newcursor = $cursor->c_dup([$flags]); $status = $cursor->c_get() ; $status = $cursor->c_put() ; $status = $cursor->c_del() ; $status = $cursor->c_count() ; $status = $cursor->c_pget() ; $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() $status = $env->setmutexlocks() $status = $env->set_flags()
$txn = $env->txn_begin() ; $db->Txn($txn); $txn->Txn($db1, $db2,...); $status = $txn->txn_prepare() $status = $txn->txn_commit() $status = $txn->txn_abort() $status = $txn->txn_id() $status = $txn->txn_discard()
$status = $env->set_lg_dir(); $status = $env->set_lg_bsize(); $status = $env->set_lg_max();
$status = $env->set_data_dir() ; $status = $env->set_tmp_dir() ; $status = $env->set_verbose() ;
$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() ;
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 versions 2, 3 and 4. 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. Note that if you are using Berkeley DB 2.x, the new features available in Berkeley DB 3.x or DB 4.x are not available via this module.
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... TODO
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.
The BerkeleyDB::Env class provides an interface to the Berkeley DB function db_appinit in Berkeley DB 2.x or db_env_create and DBENV->open in Berkeley DB 3.x/4.x. 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.
$env = new BerkeleyDB::Env
[ -Home => $path, ]
[ -Server => $name, ]
[ -CacheSize => $number, ]
[ -Config => { name => value, name => value }, ]
[ -ErrFile => filename, ]
[ -ErrPrefix => "string", ]
[ -Flags => number, ]
[ -SetFlags => bitmask, ]
[ -LockDetect => number, ]
[ -Verbose => boolean, ]
All the parameters to the BerkeleyDB::Env constructor are optional.
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
...
-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"
}
...
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
Only valid when Berkeley DB 3.x or better is used.
DB_LOCK_DEFAULT
DB_LOCK_OLDEST
DB_LOCK_RANDOM
DB_LOCK_YOUNGEST
The environment class has the following methods:
errPrefix(``string'') ;TxnMgr()This method is deprecated. Access the transaction methods using the txn_ methods below from the environment object directly.
txn_begin()txn_stat()txn_checkpoint()status()setmutexlocks()
TODO.
$status = BerkeleyDB::db_remove [OPTIONS] $status = BerkeleyDB::db_rename [OPTIONS] $status = BerkeleyDB::db_verify [OPTIONS]
=head1 THE DATABASE CLASSES
BerkeleyDB supports the following database formats:
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.
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.
Each of the database formats described above is accessed via a corresponding BerkeleyDB class. These will be described in turn in the next sections.
Equivalent to calling db_open with type DB_HASH in Berkeley DB 2.x and calling db_create followed by DB->open with type DB_HASH in Berkeley DB 3.x or greater.
Two forms of constructor are supported:
$db = new BerkeleyDB::Hash
[ -Filename => "filename", ]
[ -Subname => "sub-database name", ]
[ -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", ]
[ -Subname => "sub-database name", ]
[ -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
In addition to the standard set of options (see COMMON OPTIONS) BerkeleyDB::Hash supports these options:
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.
sub hash
{
my ($data) = shift ;
...
# return the hash value for $data
return $hash ;
}
tie %h, "BerkeleyDB::Hash",
-Filename => $filename,
-Hash => \&hash,
...
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,
-Property => DB_DUP|DB_DUPSORT,
-DupCompare => \&compare,
...
BerkeleyDB::Hash only supports the standard database methods. See COMMON DATABASE METHODS.
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.
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 ;
The code below is a variation on the examples above. This time the hash has been inverted. The key this time is colour and the value is the fruit name. The DB_DUP flag has been specified to allow duplicates.
use strict ;
use BerkeleyDB ;
my $filename = "fruit" ;
unlink $filename ;
my $db = new BerkeleyDB::Hash
-Filename => $filename,
-Flags => DB_CREATE,
-Property => DB_DUP
or die "Cannot open file $filename: $! $BerkeleyDB::Error\n" ;
# Add a few key/value pairs to the file
$db->db_put("red", "apple") ;
$db->db_put("orange", "orange") ;
$db->db_put("green", "banana") ;
$db->db_put("yellow", "banana") ;
$db->db_put("red", "tomato") ;
$db->db_put("green", "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 ;
here is the output:
orange -> orange
yellow -> banana
red -> apple
red -> tomato
green -> banana
green -> apple
In the previous example, when there were duplicate keys, the values are sorted in the order they are stored in. The code below is identical to the previous example except the DB_DUPSORT flag is specified.
use strict ;
use BerkeleyDB ;
my $filename = "fruit" ;
unlink $filename ;
my $db = new BerkeleyDB::Hash
-Filename => $filename,
-Flags => DB_CREATE,
-Property => DB_DUP | DB_DUPSORT
or die "Cannot open file $filename: $! $BerkeleyDB::Error\n" ;
# Add a few key/value pairs to the file
$db->db_put("red", "apple") ;
$db->db_put("orange", "orange") ;
$db->db_put("green", "banana") ;
$db->db_put("yellow", "banana") ;
$db->db_put("red", "tomato") ;
$db->db_put("green", "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 ;
Notice that in the output below the duplicate values are sorted.
orange -> orange
yellow -> banana
red -> apple
red -> tomato
green -> apple
green -> banana
Another variation
TODO
TODO
TODO
Equivalent to calling db_open with type DB_BTREE in Berkeley DB 2.x and calling db_create followed by DB->open with type DB_BTREE in Berkeley DB 3.x or greater.
Two forms of constructor are supported:
$db = new BerkeleyDB::Btree
[ -Filename => "filename", ]
[ -Subname => "sub-database name", ]
[ -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", ]
[ -Subname => "sub-database name", ]
[ -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,]
In addition to the standard set of options (see COMMON OPTIONS) BerkeleyDB::Btree supports these options:
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.
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,
...
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,
...
BerkeleyDB::Btree supports the following database methods. See also COMMON DATABASE METHODS.
All the methods below return 0 to indicate success.
$key, this method returns the proportion of keys less than
$key in $less, the proportion equal to $key in $equal and the
proportion greater than $key in $greater.
The proportion is returned as a double in the range 0.0 to 1.0.
The code below is a simple example of using a btree database.
use strict ;
use BerkeleyDB ;
my $filename = "tree" ;
unlink $filename ;
my %h ;
tie %h, 'BerkeleyDB::Btree',
-Filename => $filename,
-Flags => DB_CREATE
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. The keys have been sorted using Berkeley DB's default sorting algorithm.
Smith
Wall
mouse
It is possible to supply your own sorting algorithm if the one that Berkeley DB used isn't suitable. The code below is identical to the previous example except for the case insensitive compare function.
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:
TODO
Equivalent to calling db_open with type DB_RECNO in Berkeley DB 2.x and calling db_create followed by DB->open with type DB_RECNO in Berkeley DB 3.x or greater.
Two forms of constructor are supported:
$db = new BerkeleyDB::Recno
[ -Filename => "filename", ]
[ -Subname => "sub-database name", ]
[ -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", ]
[ -Subname => "sub-database name", ]
[ -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,]
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
Equivalent to calling db_create followed by DB->open with type DB_QUEUE in Berkeley DB 3.x or greater. This database format isn't available if you use Berkeley DB 2.x.
Two forms of constructor are supported:
$db = new BerkeleyDB::Queue
[ -Filename => "filename", ]
[ -Subname => "sub-database name", ]
[ -Flags => flags,]
[ -Property => flags,]
[ -Mode => number,]
[ -Cachesize => number,]
[ -Lorder => number,]
[ -Pagesize => number,]
[ -Env => $env,]
[ -Txn => $txn,]
# BerkeleyDB::Queue specific
[ -Len => number,]
[ -Pad => byte,]
[ -ExtentSize => number, ]
and this
[$db =] tie @arry, 'BerkeleyDB::Queue',
[ -Filename => "filename", ]
[ -Subname => "sub-database name", ]
[ -Flags => flags,]
[ -Property => flags,]
[ -Mode => number,]
[ -Cachesize => number,]
[ -Lorder => number,]
[ -Pagesize => number,]
[ -Env => $env,]
[ -Txn => $txn,]
# BerkeleyDB::Queue specific
[ -Len => number,]
[ -Pad => byte,]
This class is used to open an existing database.
Equivalent to calling db_open with type DB_UNKNOWN in Berkeley DB 2.x and calling db_create followed by DB->open with type DB_UNKNOWN in Berkeley DB 3.x or greater.
The constructor looks like this:
$db = new BerkeleyDB::Unknown
[ -Filename => "filename", ]
[ -Subname => "sub-database name", ]
[ -Flags => flags,]
[ -Property => flags,]
[ -Mode => number,]
[ -Cachesize => number,]
[ -Lorder => number,]
[ -Pagesize => number,]
[ -Env => $env,]
[ -Txn => $txn,]
All database access class constructors support the common set of options defined below. All are optional.
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.
Defaults to no environment.
All the database interfaces support the common set of methods defined below.
All the methods below return 0 to indicate success.
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:
$key and $value in the database.
In addition, the following value may be set by logically OR'ing it into the $flags parameter:
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:
TODO.
$key already exists in the database,
the call to db_put will return DB_KEYEXIST.
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.
db_sync()If any parts of the database are in memory, write them to the database.
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:
TODO
partial_clear() ;TODO
byteswapped()TODO
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.
db_stat()
$version = $ref->{'bt_version'} ;
If you are using Berkeley DB 3.x or better, this method will work will all database formats. When DB 2.x is used, it only works with BerkeleyDB::Btree.
status()Returns the status of the last $db method called.
truncate($count)Truncates the datatabase and returns the number or records deleted
in $count.
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:
c_dup($flags)Creates a duplicate of $cursor. This method needs Berkeley DB 3.0.x or better.
The $flags parameter is optional and can take the following value:
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:
$key and $value.
$key and $value.
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.
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.
In addition, the following value may be set by logically OR'ing it into the $flags parameter:
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:
When used with a Recno ... TODO
When used with a Recno ... TODO
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.
Stores the number of duplicates at the current cursor position in $cnt.
The $flags parameter is not used at present. This method needs Berkeley DB 3.1 or better.
status()Returns the status of the last cursor method as a dual type.
TODO
Iterating from first to last, then in reverse.
examples of each of the flags.
Join support for BerkeleyDB is in progress. Watch this space.
TODO
TODO.
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:
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.
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.
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 = "filt.db" ;
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.
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 = "filt.db" ;
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.
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 MLDBM documentation for information on how to use the module and for details of its limitations.
TODO.
There is no technical reason why a Berkeley DB database cannot be shared by both a Perl and a C application.
The vast majority of problems that are reported in this area boil down to the fact that C strings are NULL terminated, whilst Perl strings are not. See An Example -- the NULL termination problem. in the DBM FILTERS section for a generic way to work around this problem.
TODO
This section attempts to answer some of the more common questions that I get asked.
Before Berkeley DB 2.x was written there was only one Perl module that interfaced to Berkeley DB. That module is called DB_File. Although DB_File can be build with Berkeley DB 1.x, 2.x, 3.x or 4.x, it only provides an interface to the functionality available in Berkeley DB 1.x. That means that it doesn't support transactions, locking or any of the other new features available in DB 2.x or better.
See Using BerkeleyDB with MLDBM.
See the Changes file.
The most recent version of BerkeleyDB can always be found on CPAN (see CPAN in the perlmod manpage for details), in the directory modules/by-module/BerkeleyDB.
The official web site for Berkeley DB is http://www.sleepycat.com.
Copyright (c) 1997-2002 Paul Marquess. All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
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 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.
Paul Marquess <Paul.Marquess@btinternet.com>.
Questions about Berkeley DB may be addressed to <db@sleepycat.com>.
perl(1), DB_File, Berkeley DB.
|
BerkeleyDB - Perl extension for Berkeley DB version 2, 3 or 4 |