Db::del()
Prev | Chapter 2. The Db Handle | Next

## Db::del()

    #include <db_cxx.h>

    int
    Db::del(DbTxn *txnid, Dbt *key, u_int32_t flags);

The `Db::del()` method removes key/data pairs from the database. The key/data pair associated with the specified key is discarded from the database. In the presence of duplicate key values, all records associated with the designated key will be discarded.

When called on a database that has been made into a secondary index using the Db::associate() method, the `Db::del()` method deletes the key/data pair from the primary database and all secondary indices.

The `Db::del()` method will return DB_NOTFOUND if the specified key is not in the database. The `Db::del()` method will return DB_KEYEMPTY if the database is a Queue or Recno database and the specified key exists, but was never explicitly created by the application or was later deleted. Unless otherwise specified, the `Db::del()` 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.

### Parameters

#### txnid

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.

#### key

The key Dbt operated on.

#### flags

The flags parameter must be set to 0 or one of the following values:

- `DB_CONSUME`

  If the database is of type DB_QUEUE then this flag may be set to force the head of the queue to move to the first non-deleted item in the queue. Normally this is only done if the deleted item is exactly at the head when deleted.

- `DB_MULTIPLE`

  Delete multiple data items using keys from the buffer to which the key parameter refers.

  To delete records in bulk by key with the btree or hash access methods, construct a bulk buffer in the key Dbt using DbMultipleDataBuilder. To delete records in bulk by record number, construct a bulk buffer in the key Dbt using DbMultipleRecnoDataBuilder with a data size of zero.

  A successful bulk delete operation is logically equivalent to a loop through each key/data pair, performing a Db::del() for each one.

  See the DBT and Bulk Operations for more information on working with bulk updates.

  The `DB_MULTIPLE` flag may only be used alone.

- `DB_MULTIPLE_KEY`

  Delete multiple data items using keys and data from the buffer to which the key parameter refers.

  To delete records in bulk with the btree or hash access methods, construct a bulk buffer in the key Dbt using DbMultipleKeyDataBuilder. To delete records in bulk with the recno or hash access methods, construct a bulk buffer in the key Dbt using DbMultipleRecnoDataBuilder.

  See the DBT and Bulk Operations for more information on working with bulk updates.

  The `DB_MULTIPLE_KEY` flag may only be used alone.

### Errors

The `Db::del()` 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:

#### DB_FOREIGN_CONFLICT

A foreign key constraint violation has occurred. This can be caused by one of two things:

1. An attempt was made to add a record to a constrained database, and the key used for that record does not exist in the foreign key database.

2. DB_FOREIGN_ABORT was declared for a foreign key database, and then subsequently a record was deleted from the foreign key database without first removing it from the constrained secondary database.

#### DbDeadlockException or DB_LOCK_DEADLOCK

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.

#### DbLockNotGrantedException or DB_LOCK_NOTGRANTED

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.

#### DbRepHandleDeadException or DB_REP_HANDLE_DEAD

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.

#### DbDeadlockException or DB_REP_LOCKOUT

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.

#### DB_SECONDARY_BAD

A secondary index references a nonexistent primary key.

#### EACCES

An attempt was made to modify a read-only database.

#### EINVAL

An invalid flag value or parameter was specified.

### Class

Db

### See Also

Database and Related Methods

Prev | Up | Next
Db::compact() | Home | Db::err()