"DB- put: method not permitted before handle's open method"

Question

Hi,
A deadlock caused during a read/update/write circle. After aborting and
recreating the transaction, I get the error message:
DB->put: method not permitted before handle's open method
To produce the error, set a breakpoint to "Set the breakpoint here", start the
programm, wait until the debuger is there, start the same program a second time,
now the deadlock occurs.
Break the deadlock of the first process: "db_deadlock -ao"
The first process (broken by "db_deadlock" runs into the transaction recovery
section and creates the error-message.
System: MinGW
The below code is simplified:
#include <malloc.h>
#include <string.h>
#include <sys/stat.h>
#include <db.h>
#define FLAG_ENV_OPEN DB_CREATE | DB_INIT_MPOOL | DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_TXN | DB_REGISTER | DB_RECOVER
int main( int argc, char *argv[] )
const char *environment_directory = "C:\\Temp";
const char *database_file = "C:\\Temp\\test.db";
const char *key_data = "key";
const char *data_data = "there is something";
DBT key, data;
// If database does not exists, create a database with one element
struct stat buffer;
int status = stat( database_file, &buffer );
if( status != 0 )
DB *database_handle = NULL;
int status = db_create( &database_handle, NULL, 0 );
status = database_handle->set_flags( database_handle, DB_RECNUM );
status = database_handle->open( database_handle, NULL, database_file, NULL, DB_BTREE, DB_CREATE, 0644 );
memset( &key, 0, sizeof(DBT) );
key.data = (void*)key_data;
key.size = strlen(key_data);
key.flags = DB_DBT_USERMEM;
memset( &data, 0, sizeof(DBT) );
data.data = (void*)data_data;
data.size = strlen(data_data);
data.flags = DB_DBT_USERMEM;
status = database_handle->put( database_handle, NULL, &key, &data, 0 );
database_handle->close( database_handle, 0 );
// Create environment
DB_ENV *environment = NULL;
status = db_env_create( &environment, 0 );
status = environment->set_cachesize( environment, 0, 4 * 1024 * 1024, 0 );
status = environment->open( environment, environment_directory, FLAG_ENV_OPEN, 0644 );
// Create transaction
DB_TXN *transaction = NULL;
status = environment->txn_begin( environment, NULL, &transaction, 0 );
// Open the created database
DB *database_handle = NULL;
status = db_create( &database_handle, environment, 0 );
status = database_handle->set_flags( database_handle, DB_RECNUM );
status = database_handle->open( database_handle, transaction, database_file, NULL, DB_BTREE, DB_CREATE, 0644 );
// Create a read lock
memset( &key, 0, sizeof(DBT) );
key.data = (void*)key_data;
key.size = strlen(key_data);
key.flags = DB_DBT_USERMEM;
memset( &data, 0, sizeof(DBT) );
data.data = NULL;
data.flags = 0;
status = database_handle->get( database_handle, transaction, &key, &data, 0 );
// Create a write lock
memset( &key, 0, sizeof(DBT) );
key.data = (void*)key_data;
key.size = strlen(key_data);
key.flags = DB_DBT_USERMEM;
memset( &data, 0, sizeof(DBT) );
data.data = (void*)data_data;
data.size = strlen(data_data);
data.flags = DB_DBT_USERMEM;
// Set the breakpoint here:
status = database_handle->put( database_handle, transaction, &key, &data, 0 );
// Should be deadlock
if( status == DB_LOCK_DEADLOCK )
status = transaction->abort( transaction );
status = environment->txn_begin( environment, NULL, &transaction, 0 );
// Here is the problem
status = database_handle->put( database_handle, transaction, &key, &data, 0 );
// Close database
database_handle->close( database_handle, 0 );
// Close environment
environment->close( environment, 0 );
return 0;
}

Answer 1

Hi,
The issue in your test case is the use of a transaction handle in the DB->open call, followed by an abort of that transaction. This aborts the DB->open operation, which is not what you intend.
It is almost always simplest to pass NULL for the transaction handle to the DB->open call and add the DB_AUTO_COMMIT flag instead. Then if the open call succeeds, you have a database handle that is valid regardless of subsequent transaction aborts.
Regards,
Michael Cahill, Oracle.