#include <db_cxx.h>
int
Db::key_range(DbTxn *txnid
Dbt *key, DB_KEY_RANGE *key_range, u_int32_t flags);
The Db::key_range() method returns an estimate of the proportion of
keys that are less than, equal to, and greater than the specified key.
The underlying database must be of type Btree.
The Db::key_range() method fills in a structure of type DB_KEY_RANGE.
The following data fields are available from the DB_KEY_RANGE
structure:
double less;
A value between 0 and 1, the proportion of keys less than the specified key.
double equal;
A value between 0 and 1, the proportion of keys equal to the specified key.
double greater;
A value between 0 and 1, the proportion of keys greater than the specified key.
Values are in the range of 0 to 1; for example, if the field less is 0.05, 5% of the keys in the database are less than the key parameter. The value for equal will be zero if there is no matching key, and will be non-zero otherwise.
The Db::key_range()
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.
The key Dbt operated on.
The estimates are returned in the key_range parameter, which contains three elements of type double: less, equal, and greater. Values are in the range of 0 to 1; for example, if the field less is 0.05, 5% of the keys in the database are less than the key parameter. The value for equal will be zero if there is no matching key, and will be non-zero otherwise.
If the operation is part of an application-specified transaction, the
txnid parameter is a transaction
handle returned from DbEnv::txn_begin();
if the operation is part of a Berkeley DB Concurrent Data Store group, the
txnid parameter is a handle returned
from DbEnv::cdsgroup_begin();
otherwise NULL. If no transaction handle is specified, but the
operation occurs in a transactional database, the operation will be
implicitly transaction protected. The Db::key_range() method does not
retain the locks it acquires for the life of the transaction, so
estimates may not be repeatable.
The Db::key_range()
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:
A transactional database environment operation was selected to resolve a deadlock.
DbDeadlockException is thrown if
your Berkeley DB API is configured to throw exceptions.
Otherwise, DB_LOCK_DEADLOCK is returned.
A Berkeley DB Concurrent Data Store database environment configured for lock timeouts was unable to grant a lock in the allowed time.
DbLockNotGrantedException is thrown if
your Berkeley DB API is configured to throw exceptions.
Otherwise, DB_LOCK_NOTGRANTED is returned.
When a client synchronizes with the master, it is possible for committed
transactions to be rolled back. This invalidates all the database and cursor
handles opened in the replication environment. Once this occurs, an attempt to use
such a handle will
throw a DbRepHandleDeadException (if
your application is configured to throw exceptions), or
return DB_REP_HANDLE_DEAD.
The application will need to discard the handle and open a new one in order to
continue processing.
The operation was blocked by client/master synchronization.
DbDeadlockException is thrown if
your Berkeley DB API is configured to throw exceptions.
Otherwise, DB_REP_LOCKOUT is returned.