#include <db_cxx.h>
int
Db::verify(const char *file,
const char *database, ostream *outfile, u_int32_t flags);
The Db::verify() method verifies the integrity of all databases in
the file specified by the file
parameter, and optionally outputs the databases' key/data pairs to the
file stream specified by the outfile
parameter.
The Db::verify() method does not perform any
locking, even in Berkeley DB environments that are configured with a
locking subsystem. As such, it should only be used on files that are
not being modified by another thread of control.
The Db::verify() method may not be called after the
Db::open()
method is called.
The Db handle may not be
accessed again after Db::verify() is called, regardless of its
return.
The Db::verify() method will return DB_VERIFY_BAD if a database is
corrupted. When the DB_SALVAGE flag is specified, the DB_VERIFY_BAD
return means that all key/data pairs in the file may not have been
successfully output. Unless otherwise specified, the Db::verify()
method either returns a non-zero error value or throws an
exception that encapsulates a non-zero error value on
failure, and returns 0 on success.
When called on a database that has been opened with sliced
support, the Db::verify() method is
automatically called on each supporting slice database.
The database parameter is the database in file on which the database checks for btree and duplicate sort order and for hashing are to be performed. See the DB_ORDERCHKONLY flag for more information.
The database parameter must be set to NULL except when the DB_ORDERCHKONLY flag is set.
The outfile parameter is an optional file stream to which the databases' key/data pairs are written.
The flags parameter must be set to 0 or the following value:
Write the key/data pairs from all databases in the file to the file stream named in the outfile parameter. Key values are written for Btree, Hash and Queue databases, but not for Recno databases.
The output format is the same as that specified for the db_dump utility, and can be used as input for the db_load utility.
Because the key/data pairs are output in page order as opposed to the
sort order used by db_dump, using Db::verify() to
dump key/data pairs normally produces less than optimal loads for
Btree databases.
In addition, the following flags may be set by bitwise inclusively OR'ing them into the flags parameter:
Output all the key/data pairs in the
file that can be found. By default, Db::verify() does not assume
corruption. For example, if a key/data pair on a page is marked as
deleted, it is not then written to the output file. When
DB_AGGRESSIVE is specified, corruption is assumed, and any key/data
pair that can be found is written. In this case, key/data pairs that
are corrupted or have been deleted may appear in the output (even if
the file being salvaged is in no way corrupt), and the output will
almost certainly require editing before being loaded into a database.
When using the DB_SALVAGE flag, if characters in either the key or data items are printing characters (as defined by isprint(3)), use printing characters to represent them. This flag permits users to use standard text editors and tools to modify the contents of databases or selectively remove data from salvager output.
Note: different systems may have different notions about what characters are considered printing characters, and databases dumped in this manner may be less portable to external systems.
Skip the database checks for btree and duplicate sort order and for hashing.
The Db::verify() method normally verifies that btree keys and
duplicate items are correctly sorted, and hash keys are correctly
hashed. If the file being verified contains multiple databases using
differing sorting or hashing algorithms, some of them must necessarily
fail database verification because only one sort order or hash
function can be specified before Db::verify() is called. To verify
files with multiple databases having differing sorting orders or
hashing functions, first perform verification of the file as a whole
by using the DB_NOORDERCHK flag, and then individually verify the sort
order and hashing function for each database in the file using the
DB_ORDERCHKONLY flag.
Perform the database checks for btree and duplicate sort order and for hashing, skipped by DB_NOORDERCHK.
When this flag is specified, a database parameter should also be specified,
indicating the database in the physical file which is to be checked.
This flag is only safe to use on databases that have already
successfully been verified using Db::verify() with the DB_NOORDERCHK
flag set.
If the database was opened within a database environment, the
environment variable DB_HOME may be used as the path of the
database environment home.
Db::verify() is affected by any database directory specified using the
DbEnv::add_data_dir()
method, or by setting the "add_data_dir" string
in the environment's DB_CONFIG file.
The Db::verify()
method may fail and throw a DbException
exception, encapsulating one of the following non-zero errors, or return one
of the following non-zero errors:
If the method was called after Db::open() was called; or if an invalid flag value or parameter was specified.