DBD::DBM man page on AIX

Man page or keyword search:  
man Server   4752 pages
apropos Keyword Search (all sections)
Output format
AIX logo
[printable version]

DBD::DBM(3)	      User Contributed Perl Documentation	   DBD::DBM(3)

       DBD::DBM - a DBI driver for DBM & MLDBM files

	use DBI;
	$dbh = DBI->connect('dbi:DBM:');		    # defaults to SDBM_File
	$dbh = DBI->connect('DBI:DBM(RaiseError=1):');	    # defaults to SDBM_File
	$dbh = DBI->connect('dbi:DBM:dbm_type=DB_File');    # defaults to DB_File
	$dbh = DBI->connect('dbi:DBM:dbm_mldbm=Storable');  # MLDBM with SDBM_File

	# or
	$dbh = DBI->connect('dbi:DBM:', undef, undef);
	$dbh = DBI->connect('dbi:DBM:', undef, undef, {
	    f_ext	       => '.db/r',
	    f_dir	       => '/path/to/dbfiles/',
	    f_lockfile	       => '.lck',
	    dbm_type	       => 'BerkeleyDB',
	    dbm_mldbm	       => 'FreezeThaw',
	    dbm_store_metadata => 1,
	    dbm_berkeley_flags => {
		'-Cachesize' => 1000, # set a ::Hash flag

       and other variations on connect() as shown in the DBI docs,
       DBD::File/Metadata and "Metadata" shown below.

       Use standard DBI prepare, execute, fetch, placeholders, etc., see
       "QUICK START" for an example.

       DBD::DBM is a database management system that works right out of the
       box.  If you have a standard installation of Perl and DBI you can begin
       creating, accessing, and modifying simple database tables without any
       further modules.	 You can add other modules (e.g., SQL::Statement,
       DB_File etc) for improved functionality.

       The module uses a DBM file storage layer.  DBM file storage is common
       on many platforms and files can be created with it in many programming
       languages using different APIs. That means, in addition to creating
       files with DBI/SQL, you can also use DBI/SQL to access and modify files
       created by other DBM modules and programs and vice versa. Note that in
       those cases it might be necessary to use a common subset of the pro‐
       vided features.

       DBM files are stored in binary format optimized for quick retrieval
       when using a key field.	That optimization can be used advantageously
       to make DBD::DBM SQL operations that use key fields very fast.  There
       are several different "flavors" of DBM which use different storage for‐
       mats supported by perl modules such as SDBM_File and MLDBM.  This mod‐
       ule supports all of the flavors that perl supports and, when used with
       MLDBM, supports tables with any number of columns and insertion of Perl
       objects into tables.

       DBD::DBM has been tested with the following DBM types: SDBM_File,
       NDBM_File, ODBM_File, GDBM_File, DB_File, BerkeleyDB.  Each type was
       tested both with and without MLDBM and with the Data::Dumper, Storable,
       FreezeThaw, YAML and JSON serializers using the DBI::SQL::Nano or the
       SQL::Statement engines.

       DBD::DBM operates like all other DBD drivers - it's basic syntax and
       operation is specified by DBI.  If you're not familiar with DBI, you
       should start by reading DBI and the documents it points to and then
       come back and read this file.  If you are familiar with DBI, you
       already know most of what you need to know to operate this module.
       Just jump in and create a test script something like the one shown

       You should be aware that there are several options for the SQL engine
       underlying DBD::DBM, see "Supported SQL syntax".	 There are also many
       options for DBM support, see especially the section on "Adding multi-
       column support with MLDBM".

       But here's a sample to get you started.

	use DBI;
	my $dbh = DBI->connect('dbi:DBM:');
	$dbh->{RaiseError} = 1;
	for my $sql( split /;\n+/,"
	    CREATE TABLE user ( user_name TEXT, phone TEXT );
	    INSERT INTO user VALUES ('Fred Bloggs','233-7777');
	    INSERT INTO user VALUES ('Sanjay Patel','777-3333');
	    INSERT INTO user VALUES ('Junk','xxx-xxxx');
	    DELETE FROM user WHERE user_name = 'Junk';
	    UPDATE user SET phone = '999-4444' WHERE user_name = 'Sanjay Patel';
	    SELECT * FROM user
	    my $sth = $dbh->prepare($sql);
	    $sth->dump_results if $sth->{NUM_OF_FIELDS};

       This section will explain some useage cases in more detail. To get an
       overview about the available attributes, see "Metadata".

       Specifying Files and Directories

       DBD::DBM will automatically supply an appropriate file extension for
       the type of DBM you are using.  For example, if you use SDBM_File, a
       table called "fruit" will be stored in two files called "fruit.pag" and
       "fruit.dir".  You should never specify the file extensions in your SQL

       DBD::DBM recognizes following default extensions for following types:

	   Chosen for dbm_type "SDBM_File", "ODBM_File" and "NDBM_File" when
	   an implementation is detected which wraps "-ldbm" for "NDBM_File"
	   (e.g. Solaris, AIX, ...).

	   For those types, the ".dir" extension is recognized, too (for being
	   deleted when dropping a table).

	   Chosen for dbm_type "NDBM_File" when an implementation is detected
	   which wraps BerkeleyDB 1.x for "NDBM_File" (typically BSD's, Dar‐

       "GDBM_File", "DB_File" and "BerkeleyDB" don't usually use a file exten‐

       If your DBM type uses an extension other than one of the recognized
       types of extensions, you should set the f_ext attribute to the exten‐
       sion and file a bug report as described in DBI with the name of the
       implementation and extension so we can add it to DBD::DBM.  Thanks in
       advance for that :-).

	 $dbh = DBI->connect('dbi:DBM:f_ext=.db');  # .db extension is used
	 $dbh = DBI->connect('dbi:DBM:f_ext=');	    # no extension is used

	 # or
	 $dbh->{f_ext}='.db';			    # global setting
	 $dbh->{f_meta}->{'qux'}->{f_ext}='.db';    # setting for table 'qux'

       By default files are assumed to be in the current working directory.
       To use other directories specify the f_dir attribute in either the con‐
       nect string or by setting the database handle attribute.

       For example, this will look for the file /foo/bar/fruit (or
       /foo/bar/fruit.pag for DBM types that use that extension)

	 my $dbh = DBI->connect('dbi:DBM:f_dir=/foo/bar');
	 # and this will too:
	 my $dbh = DBI->connect('dbi:DBM:');
	 $dbh->{f_dir} = '/foo/bar';
	 # but this is recommended
	 my $dbh = DBI->connect('dbi:DBM:', undef, undef, { f_dir => '/foo/bar' } );

	 # now you can do
	 my $ary = $dbh->selectall_arrayref(q{ SELECT x FROM fruit });

       You can also use delimited identifiers to specify paths directly in SQL
       statements.  This looks in the same place as the two examples above but
       without setting f_dir:

	  my $dbh = DBI->connect('dbi:DBM:');
	  my $ary = $dbh->selectall_arrayref(q{
	      SELECT x FROM "/foo/bar/fruit"

       You can also tell DBD::DBM to use a specified path for a specific ta‐

	 $dbh->{dbm_tables}->{f}->{file} = q(/foo/bar/fruit);

       Please be aware that you cannot specify this during connection.

       If you have SQL::Statement installed, you can use table aliases:

	  my $dbh = DBI->connect('dbi:DBM:');
	  my $ary = $dbh->selectall_arrayref(q{
	      SELECT f.x FROM "/foo/bar/fruit" AS f

       See the "GOTCHAS AND WARNINGS" for using DROP on tables.

       Table locking and flock()

       Table locking is accomplished using a lockfile which has the same base‐
       name as the table's file but with the file extension '.lck' (or a lock‐
       file extension that you supply, see below).  This lock file is created
       with the table during a CREATE and removed during a DROP.  Every time
       the table itself is opened, the lockfile is flocked().  For SELECT,
       this is a shared lock.  For all other operations, it is an exclusive
       lock (except when you specify something different using the f_lock

       Since the locking depends on flock(), it only works on operating sys‐
       tems that support flock().  In cases where flock() is not implemented,
       DBD::DBM will simply behave as if the flock() had occurred although no
       actual locking will happen.  Read the documentation for flock() for
       more information.

       Even on those systems that do support flock(), locking is only advisory
       - as is always the case with flock().  This means that if another pro‐
       gram tries to access the table file while DBD::DBM has the table
       locked, that other program will *succeed* at opening unless it is also
       using flock on the '.lck' file.	As a result DBD::DBM's locking only
       really applies to other programs using DBD::DBM or other program writ‐
       ten to cooperate with DBD::DBM locking.

       Specifying the DBM type

       Each "flavor" of DBM stores its files in a different format and has
       different capabilities and limitations. See AnyDBM_File for a compari‐
       son of DBM types.

       By default, DBD::DBM uses the "SDBM_File" type of storage since
       "SDBM_File" comes with Perl itself. If you have other types of DBM
       storage available, you can use any of them with DBD::DBM. It is
       strongly recommended to use at least "DB_File", because "SDBM_File" has
       quirks and limitations and "ODBM_file", "NDBM_File" and "GDBM_File" are
       not always available.

       You can specify the DBM type using the dbm_type attribute which can be
       set in the connection string or with "$dbh->{dbm_type}" and
       "$dbh->{f_meta}->{$table_name}->{type}" for per-table settings in cases
       where a single script is accessing more than one kind of DBM file.

       In the connection string, just set "dbm_type=TYPENAME" where "TYPENAME"
       is any DBM type such as GDBM_File, DB_File, etc. Do not use MLDBM as
       your dbm_type as that is set differently, see below.

	my $dbh=DBI->connect('dbi:DBM:');		 # uses the default SDBM_File
	my $dbh=DBI->connect('dbi:DBM:dbm_type=GDBM_File'); # uses the GDBM_File

	# You can also use $dbh->{dbm_type} to set the DBM type for the connection:
	$dbh->{dbm_type} = 'DB_File';	 # set the global DBM type
	print $dbh->{dbm_type};		 # display the global DBM type

       If you have several tables in your script that use different DBM types,
       you can use the $dbh->{dbm_tables} hash to store different settings for
       the various tables.  You can even use this to perform joins on files
       that have completely different storage mechanisms.

	# sets global default of GDBM_File
	my $dbh->('dbi:DBM:type=GDBM_File');

	# overrides the global setting, but only for the tables called
	# I<foo> and I<bar>
	my $dbh->{f_meta}->{foo}->{dbm_type} = 'DB_File';
	my $dbh->{f_meta}->{bar}->{dbm_type} = 'BerkeleyDB';

	# prints the dbm_type for the table "foo"
	print $dbh->{f_meta}->{foo}->{dbm_type};

       Note that you must change the dbm_type of a table before you access it
       for first time.

       Adding multi-column support with MLDBM

       Most of the DBM types only support two columns and even if it would
       support more, DBD::DBM would only use two. However a CPAN module called
       MLDBM overcomes this limitation by allowing more than two columns.
       MLDBM does this by serializing the data - basically it puts a reference
       to an array into the second column. It can also put almost any kind of
       Perl object or even Perl coderefs into columns.

       If you want more than two columns, you must install MLDBM. It's avail‐
       able for many platforms and is easy to install.

       MLDBM is by default distributed with three serializers - Data::Dumper,
       Storable, and FreezeThaw. Data::Dumper is the default and Storable is
       the fastest. MLDBM can also make use of user-defined serialization
       methods or other serialization modules (e.g. YAML::MLDBM or
       MLDBM::Serializer::JSON. You select the serializer using the dbm_mldbm

       Some examples:

	$dbh=DBI->connect('dbi:DBM:dbm_mldbm=Storable');  # use MLDBM with Storable
	   'dbi:DBM:dbm_mldbm=MySerializer' # use MLDBM with a user defined module
	$dbh=DBI->connect('dbi::dbm:', undef,
	    undef, { dbm_mldbm => 'YAML' }); # use 3rd party serializer
	$dbh->{dbm_mldbm} = 'YAML'; # same as above
	print $dbh->{dbm_mldbm} # show the MLDBM serializer
	$dbh->{f_meta}->{foo}->{dbm_mldbm}='Data::Dumper';   # set Data::Dumper for table "foo"
	print $dbh->{f_meta}->{foo}->{mldbm}; # show serializer for table "foo"

       MLDBM works on top of other DBM modules so you can also set a DBM type
       along with setting dbm_mldbm.  The examples above would default to
       using SDBM_File with MLDBM.  If you wanted GDBM_File instead, here's

	# uses DB_File with MLDBM and Storable
	$dbh = DBI->connect('dbi:DBM:', undef, undef, {
	    dbm_type  => 'DB_File',
	    dbm_mldbm => 'Storable',

       SDBM_File, the default dbm_type is quite limited, so if you are going
       to use MLDBM, you should probably use a different type, see Any‐

       See below for some "GOTCHAS AND WARNINGS" about MLDBM.

       Support for Berkeley DB

       The Berkeley DB storage type is supported through two different Perl
       modules - DB_File (which supports only features in old versions of
       Berkeley DB) and BerkeleyDB (which supports all versions).  DBD::DBM
       supports specifying either "DB_File" or "BerkeleyDB" as a dbm_type,
       with or without MLDBM support.

       The "BerkeleyDB" dbm_type is experimental and it's interface is likely
       to change.  It currently defaults to BerkeleyDB::Hash and does not cur‐
       rently support ::Btree or ::Recno.

       With BerkeleyDB, you can specify initialization flags by setting them
       in your script like this:

	use BerkeleyDB;
	my $env = new BerkeleyDB::Env -Home => $dir;  # and/or other Env flags
	$dbh = DBI->connect('dbi:DBM:', undef, undef, {
	    dbm_type  => 'BerkeleyDB',
	    dbm_mldbm => 'Storable',
	    dbm_berkeley_flags => {
		'DB_CREATE'  => DB_CREATE,  # pass in constants
		'DB_RDONLY'  => DB_RDONLY,  # pass in constants
		'-Cachesize' => 1000,	    # set a ::Hash flag
		'-Env'	     => $env,	    # pass in an environment

       Do not set the -Flags or -Filename flags as those are determined and
       overwritten by the SQL (e.g. -Flags => DB_RDONLY is set automatically
       when you issue a SELECT statement).

       Time has not permitted us to provide support in this release of
       DBD::DBM for further Berkeley DB features such as transactions, concur‐
       rency, locking, etc. We will be working on these in the future and
       would value suggestions, patches, etc.

       See DB_File and BerkeleyDB for further details.

       Optimizing the use of key fields

       Most "flavors" of DBM have only two physical columns (but can contain
       multiple logical columns as explained above in "Adding multi-column
       support with MLDBM"). They work similarly to a Perl hash with the first
       column serving as the key. Like a Perl hash, DBM files permit you to do
       quick lookups by specifying the key and thus avoid looping through all
       records (supported by DBI::SQL::Nano only). Also like a Perl hash, the
       keys must be unique. It is impossible to create two records with the
       same key.  To put this more simply and in SQL terms, the key column
       functions as the PRIMARY KEY or UNIQUE INDEX.

       In DBD::DBM, you can take advantage of the speed of keyed lookups by
       using DBI::SQL::Nano and a WHERE clause with a single equal comparison
       on the key field. For example, the following SQL statements are opti‐
       mized for keyed lookup:

	CREATE TABLE user ( user_name TEXT, phone TEXT);
	INSERT INTO user VALUES ('Fred Bloggs','233-7777');
	# ... many more inserts
	SELECT phone FROM user WHERE user_name='Fred Bloggs';

       The "user_name" column is the key column since it is the first column.
       The SELECT statement uses the key column in a single equal comparison -
       "user_name='Fred Bloggs'" - so the search will find it very quickly
       without having to loop through all the names which were inserted into
       the table.

       In contrast, these searches on the same table are not optimized:

	1. SELECT phone FROM user WHERE user_name < 'Fred';
	2. SELECT user_name FROM user WHERE phone = '233-7777';

       In #1, the operation uses a less-than (<) comparison rather than an
       equals comparison, so it will not be optimized for key searching.  In
       #2, the key field "user_name" is not specified in the WHERE clause, and
       therefore the search will need to loop through all rows to find the
       requested row(s).

       Note that the underlying DBM storage needs to loop over all key/value
       pairs when the optimized fetch is used. SQL::Statement has a massively
       improved where clause evaluation which costs around 15% of the evalua‐
       tion in DBI::SQL::Nano - combined with the loop in the DBM storage the
       speed improvement isn't so impressive.

       Even if lookups are faster by around 50%, DBI::SQL::Nano and
       SQL::Statement can benefit from the key field optimizations on updating
       and deleting rows - and here the improved where clause evaluation of
       SQL::Statement might beat DBI::SQL::Nano every time the where clause
       contains not only the key field (or more than one).

       Supported SQL syntax

       DBD::DBM uses a subset of SQL.  The robustness of that subset depends
       on what other modules you have installed. Both options support basic
       SQL operations including CREATE TABLE, DROP TABLE, INSERT, DELETE,
       UPDATE, and SELECT.

       Option #1: By default, this module inherits its SQL support from
       DBI::SQL::Nano that comes with DBI.  Nano is, as its name implies, a
       *very* small SQL engine.	 Although limited in scope, it is faster than
       option #2 for some operations (especially single primary key lookups).
       See DBI::SQL::Nano for a description of the SQL it supports and compar‐
       isons of it with option #2.

       Option #2: If you install the pure Perl CPAN module SQL::Statement,
       DBD::DBM will use it instead of Nano.  This adds support for table
       aliases, functions, joins, and much more.  If you're going to use
       DBD::DBM for anything other than very simple tables and queries, you
       should install SQL::Statement.  You don't have to change DBD::DBM or
       your scripts in any way, simply installing SQL::Statement will give you
       the more robust SQL capabilities without breaking scripts written for
       DBI::SQL::Nano.	See SQL::Statement for a description of the SQL it

       To find out which SQL module is working in a given script, you can use
       the dbm_versions() method or, if you don't need the full output and
       version numbers, just do this:

	print $dbh->{sql_handler}, "\n";

       That will print out either "SQL::Statement" or "DBI::SQL::Nano".

       Baring the section about optimized access to the DBM storage in mind,
       comparing the benefits of both engines:

	 # DBI::SQL::Nano is faster
	 $sth = $dbh->prepare( "update foo set value='new' where key=15" );
	 $sth = $dbh->prepare( "delete from foo where key=27" );
	 $sth = $dbh->prepare( "select * from foo where key='abc'" );

	 # SQL::Statement might faster (depending on DB size)
	 $sth = $dbh->prepare( "update foo set value='new' where key=?" );
	 $sth = $dbh->prepare( "update foo set value=? where key=15" );
	 $sth = $dbh->prepare( "delete from foo where key=?" );

	 # SQL::Statement is faster
	 $sth = $dbh->prepare( "update foo set value='new' where value='old'" );
	 # must be expressed using "where key = 15 or key = 27 or key = 42 or key = 'abc'"
	 # in DBI::SQL::Nano
	 $sth = $dbh->prepare( "delete from foo where key in (15,27,42,'abc')" );
	 # must be expressed using "where key > 10 and key < 90" in DBI::SQL::Nano
	 $sth = $dbh->prepare( "select * from foo where key between (10,90)" );

	 # only SQL::Statement can handle
	 $sth->prepare( "select * from foo,bar where foo.name = bar.name" );
	 $sth->prepare( "insert into foo values ( 1, 'foo' ), ( 2, 'bar' )" );

       Specifying Column Names

       DBM files don't have a standard way to store column names.   DBD::DBM
       gets around this issue with a DBD::DBM specific way of storing the col‐
       umn names.  If you are working only with DBD::DBM and not using files
       created by or accessed with other DBM programs, you can ignore this

       DBD::DBM stores column names as a row in the file with the key _meta‐
       data \0.	 So this code

	my $dbh = DBI->connect('dbi:DBM:');
	$dbh->do("CREATE TABLE baz (foo CHAR(10), bar INTEGER)");
	$dbh->do("INSERT INTO baz (foo,bar) VALUES ('zippy',1)");

       Will create a file that has a structure something like this:

	 _metadata \0 ⎪ <dbd_metadata><schema></schema><col_names>foo,bar</col_names></dbd_metadata>
	 zippy	      ⎪ 1

       The next time you access this table with DBD::DBM, it will treat the
       _metadata \0 row as a header rather than as data and will pull the col‐
       umn names from there.  However, if you access the file with something
       other than DBD::DBM, the row will be treated as a regular data row.

       If you do not want the column names stored as a data row in the table
       you can set the dbm_store_metadata attribute to 0.

	my $dbh = DBI->connect('dbi:DBM:', undef, undef, { dbm_store_metadata => 0 });

	# or
	$dbh->{dbm_store_metadata} = 0;

	# or for per-table setting
	$dbh->{f_meta}->{qux}->{dbm_store_metadata} = 0;

       By default, DBD::DBM assumes that you have two columns named "k" and
       "v" (short for "key" and "value").  So if you have dbm_store_metadata
       set to 1 and you want to use alternate column names, you need to spec‐
       ify the column names like this:

	my $dbh = DBI->connect('dbi:DBM:', undef, undef, {
	    dbm_store_metadata => 0,
	    dbm_cols => [ qw(foo bar) ],

	# or
	$dbh->{dbm_store_metadata} = 0;
	$dbh->{dbm_cols}	   = 'foo,bar';

	# or to set the column names on per-table basis, do this:
	# sets the column names only for table "qux"
	$dbh->{f_meta}->{qux}->{dbm_store_metadata} = 0;
	$dbh->{f_meta}->{qux}->{col_names}	    = [qw(foo bar)];

       If you have a file that was created by another DBM program or created
       with dbm_store_metadata set to zero and you want to convert it to using
       DBD::DBM's column name storage, just use one of the methods above to
       name the columns but *without* specifying dbm_store_metadata as zero.
       You only have to do that once - thereafter you can get by without set‐
       ting either dbm_store_metadata or setting dbm_cols because the names
       will be stored in the file.

DBI database handle attributes

       Statement handle ($sth) attributes and methods

       Most statement handle attributes such as NAME, NUM_OF_FIELDS, etc. are
       available only after an execute.	 The same is true of $sth->rows which
       is available after the execute but does not require a fetch.

       Driver handle ($dbh) attributes

       It is not supported anymore to use dbm-attributes without the dbm_-pre‐
       fix.  Currently, if an DBD::DBM private attribute is accessed without
       an underscore in it's name, dbm_ is prepended to that attribute and
       it's processed further. If the resulting attribute name is invalid, an
       error is thrown.


       Contains a comma separated list of column names or an array reference
       to the column names.


       Contains the DBM storage type. Currently known supported type are
       "ODBM_File", "NDBM_File", "SDBM_File", "GDBM_File", "DB_File" and
       "BerkeleyDB". It is not recommended to use one of the first three types
       - even if "SDBM_File" is the most commonly available dbm_type.


       Contains the serializer for DBM storage (value column). Requires the
       CPAN module MLDBM installed.  Currently known supported serializers

	       Default serializer. Deployed with Perl core.

	       Faster serializer. Deployed with Perl core.

	       Pure Perl serializer, requires FreezeThaw to be installed.

       YAML    Portable serializer (between languages but not architectures).
	       Requires YAML::MLDBM installation.

       JSON    Portable, fast serializer (between languages but not architec‐
	       tures).	Requires MLDBM::Serializer::JSON installation.


       Boolean value which determines if the metadata in DBM is stored or not.


       Hash reference with additional flags for BerkeleyDB::Hash instantia‐


       Readonly attribute containing the version of DBD::DBM.


       In addition to the attributes DBD::File recognizes, DBD::DBM knows
       about the (public) attributes "col_names" (Note not dbm_cols here!),
       "dbm_type", "dbm_mldbm", "dbm_store_metadata" and "dbm_berkeley_flags".
       As in DBD::File, there are undocumented, internal attributes in
       DBD::DBM.  Be very careful when modifying attributes you do not know;
       the consequence might a destroyed or corrupted table.


       This attribute provides restricted access to the table meta data. See
       f_meta and "f_meta" in DBD::File for attribute details.

       dbm_tables is a tied hash providing the internal table names as keys
       (accessing unknown tables might create an entry) and their meta data as
       another tied hash. The table meta storage is obtained via the "get_ta‐
       ble_meta" method from the table implementation (see DBD::File::Develop‐
       ers). Attribute setting and getting within the table meta data is han‐
       dled via the methods "set_table_meta_attr" and "get_table_meta_attr".

       Following attributes are no longer handled by DBD::DBM:


       This attribute is silently mapped to DBD::File's attribute f_ext.
       Later versions of DBI might show a depreciated warning when this
       attribute is used and eventually it will be removed.


       This attribute is silently mapped to DBD::File's attribute f_lockfile.
       Later versions of DBI might show a depreciated warning when this
       attribute is used and eventually it will be removed.

DBI database handle methods
       The $dbh->dbm_versions() method

       The private method dbm_versions() returns a summary of what other mod‐
       ules are being used at any given time.  DBD::DBM can work with or with‐
       out many other modules - it can use either SQL::Statement or
       DBI::SQL::Nano as its SQL engine, it can be run with DBI or
       DBI::PurePerl, it can use many kinds of DBM modules, and many kinds of
       serializers when run with MLDBM.	 The dbm_versions() method reports all
       of that and more.

	 print $dbh->dbm_versions;		 # displays global settings
	 print $dbh->dbm_versions($table_name);	 # displays per table settings

       An important thing to note about this method is that when it called
       with no arguments, it displays the *global* settings.  If you override
       these by setting per-table attributes, these will not be shown unless
       you specify a table name as an argument to the method call.

       Storing Objects

       If you are using MLDBM, you can use DBD::DBM to take advantage of its
       serializing abilities to serialize any Perl object that MLDBM can han‐
       dle.  To store objects in columns, you should (but don't absolutely
       need to) declare it as a column of type BLOB (the type is *currently*
       ignored by the SQL engine, but it's good form).

	       Improved SQL engine compared to the built-in DBI::SQL::Nano -
	       see "Supported SQL syntax".

	       Berkeley DB version 1. This database library is available on
	       many systems without additional installation and most systems
	       are supported.

	       Simple dbm type (comparable to "DB_File") under the GNU
	       license.	 Typically not available (or requires extra installa‐
	       tion) on non-GNU operating systems.

	       Berkeley DB version up to v4 (and maybe higher) - requires
	       additional installation but is easier than GDBM_File on non-GNU

	       db4 comes with a many tools which allow repairing and migrating
	       databases.  This is the recommended dbm type for production

       "MLDBM" Serializer wrapper to support more than one column for the
	       files.  Comes with serializers using "Data::Dumper",
	       "FreezeThaw" and "Storable".

	       Additional serializer for MLDBM. YAML is very portable between

	       Additional serializer for MLDBM. JSON is very portable between
	       languanges, probably more than YAML.

       Using the SQL DROP command will remove any file that has the name spec‐
       ified in the command with either '.pag' and '.dir', '.db' or your
       {f_ext} appended to it.	So this be dangerous if you aren't sure what
       file it refers to:

	$dbh->do(qq{DROP TABLE "/path/to/any/file"});

       Each DBM type has limitations.  SDBM_File, for example, can only store
       values of less than 1,000 characters.  *You* as the script author must
       ensure that you don't exceed those bounds.  If you try to insert a
       value that is larger than DBM can store, the results will be unpre‐
       dictable.  See the documentation for whatever DBM you are using for

       Different DBM implementations return records in different orders.  That
       means that you should not rely on the order of records unless you use
       an ORDER BY statement.

       DBM data files are platform-specific.  To move them from one platform
       to another, you'll need to do something along the lines of dumping your
       data to CSV on platform #1 and then dumping from CSV to DBM on platform
       #2.  DBD::AnyData and DBD::CSV can help with that.  There may also be
       DBM conversion tools for your platforms which would probably be

       When using MLDBM, there is a very powerful serializer - it will allow
       you to store Perl code or objects in database columns.  When these get
       de-serialized, they may be eval'ed - in other words MLDBM (or actually
       Data::Dumper when used by MLDBM) may take the values and try to execute
       them in Perl.  Obviously, this can present dangers, so if you do not
       know what is in a file, be careful before you access it with MLDBM
       turned on!

       See the entire section on "Table locking and flock()" for gotchas and
       warnings about the use of flock().

       This module uses hash interfaces of two column file databases. While
       none of supported SQL engines have support for indices, the following
       statements really do the same (even if they mean something completely
       different) for each dbm type which lacks "EXISTS" support:

	 $sth->do( "insert into foo values (1, 'hello')" );

	 # this statement does ...
	 $sth->do( "update foo set v='world' where k=1" );
	 # ... the same as this statement
	 $sth->do( "insert into foo values (1, 'world')" );

       This is considered to be a bug and might change in a future release.

       Known affected dbm types are "ODBM_File" and "NDBM_File". We highly
       recommended you use a more modern dbm type such as "DB_File".

       If you need help installing or using DBD::DBM, please write to the DBI
       users mailing list at dbi-users@perl.org or to the comp.lang.perl.mod‐
       ules newsgroup on usenet.  I cannot always answer every question
       quickly but there are many on the mailing list or in the newsgroup who

       DBD developers for DBD's which rely on DBD::File or DBD::DBM or use one
       of them as an example are suggested to join the DBI developers mailing
       list at dbi-dev@perl.org and strongly encouraged to join our IRC chan‐
       nel at <irc://irc.perl.org/dbi>.

       If you have suggestions, ideas for improvements, or bugs to report,
       please report a bug as described in DBI. Do not mail any of the authors
       directly, you might not get an answer.

       When reporting bugs, please send the output of $dbh->dbm_versions($ta‐
       ble) for a table that exhibits the bug and as small a sample as you can
       make of the code that produces the bug.	And of course, patches are
       welcome, too :-).

       If you need enhancements quickly, you can get commercial support as
       described at <http://dbi.perl.org/support/> or you can contact Jens
       Rehsack at rehsack@cpan.org for commercial support in Germany.

       Please don't bother Jochen Wiedmann or Jeff Zucker for support - they
       handed over further maintenance to H.Merijn Brand and Jens Rehsack.

       Many, many thanks to Tim Bunce for prodding me to write this, and for
       copious, wise, and patient suggestions all along the way. (Jeff Zucker)

       I send my thanks and acknowledgements to H.Merijn Brand for his initial
       refactoring of DBD::File and his strong and ongoing support of
       SQL::Statement. Without him, the current progress would never have been
       made.  And I have to name Martin J. Evans for each laugh (and correc‐
       tion) of all those funny word creations I (as non-native speaker) made
       to the documentation. And - of course - I have to thank all those
       unnamed contributors and testers from the Perl community. (Jens Reh‐

       This module is written by Jeff Zucker < jzucker AT cpan.org >, who also
       maintained it till 2007. After that, in 2010, Jens Rehsack & H.Merijn
       Brand took over maintenance.

	Copyright (c) 2004 by Jeff Zucker, all rights reserved.
	Copyright (c) 2010 by Jens Rehsack & H.Merijn Brand, all rights reserved.

       You may freely distribute and/or modify this module under the terms of
       either the GNU General Public License (GPL) or the Artistic License, as
       specified in the Perl README file.

       DBI, SQL::Statement, DBI::SQL::Nano, AnyDBM_File, DB_File, BerkeleyDB,
       MLDBM, YAML::MLDBM, MLDBM::Serializer::JSON

perl v5.8.8			  2010-12-21			   DBD::DBM(3)
                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server AIX

List of man pages available for AIX

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net