mdbx 0.1.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e88f3e5ea2e66b7e924500a33f25f635c712e359bd0f8e19c52f60605bcafe46
-  data.tar.gz: c069a2b838b86f1cc9873613ad1b99c1f888f24eab395c9f264d830aa7ba810d
+  metadata.gz: 678369c278e65d4faf56eb814e2cb7eba22da57fb5c07c6e4f9dc4e6edd7f09f
+  data.tar.gz: 0fc4b455b4556bb932f867fa40e7c240f555a5a6bbb7d09cb55c68ed7745bfd0
 SHA512:
-  metadata.gz: 6d575ad77ff4c72382d13852d0d075c8b8caa664f8e55ace63e0e638695cd2cff43d2580484abff76fce0cf4efa60b8423d4330d65d1a1f39da07c8cd93ea7e9
-  data.tar.gz: 895d6aee64d76e6e2b62071ae7d1cc98aa4d692d2b377c0d04e6f9f5ebb7495f23db7dafa66c8a2cdaf6a9a1925f003fca6d02e4646e4a23bf415167050dc0b4
+  metadata.gz: b9844be65fc6e46df8dbaee242ce9bf185c4330559d2a5d8c803eca43f4d09a783276c3d2a20258ef84be099a133031acf0f0b36ff0c2af1f69d0882a0dd4335
+  data.tar.gz: 22fd3c418db16d2a58100ad6bd8f3ae7b7ddce2172075713a798065440e59f6a2fd4cea47bd37d3585781dbeaebc0421f483e20375a5e652fe3a81ee76e0da2f

data/History.md

@@ -1,6 +1,68 @@
 # Release History for MDBX
 
 ---
+## v0.3.2 [2021-07-13] Mahlon E. Smith <mahlon@martini.nu>
+
+Bugfixes:
+
+ - Fix double memory allocation during initialization.
+ - Make various ruby->c string allocations safe with the garbage collector.
+
+
+Minutiae:
+
+ - Raise exception if instantiating with invalid options.
+
+
+---
+## v0.3.1 [2021-05-16] Mahlon E. Smith <mahlon@martini.nu>
+
+Bugfix:
+
+ - #drop could potentially remove unintended data.  Yanked version
+   v0.3.0.
+
+
+---
+## v0.3.0 [2021-04-09] Mahlon E. Smith <mahlon@martini.nu>
+
+Enhancements:
+
+ - Alter the behavior of #clear, so it doesn't destroy collection
+   environments, but just empties them.
+
+ - Add #drop, which explictly -does- destroy a collection environment.
+
+ - Switching to a collection now automatically creates its environment.
+
+ - Add include? and has_key?, for presence checks without allocating
+   value memory or requiring deserialization.
+
+
+Bugfixes:
+
+ - Run all cursor methods through rb_protect, to ensure proper
+   cursor cleanup in the event of an exception mid iteration.
+
+ - Fix the block form of collections to support multiple scopes.
+
+
+## v0.2.1 [2021-04-06] Mahlon E. Smith <mahlon@martini.nu>
+
+Enhancement:
+
+- Automatically stringify any argument to the collection() method.
+
+
+## v0.2.0 [2021-03-19] Mahlon E. Smith <mahlon@martini.nu>
+
+Enhancement:
+
+- Support dup/clone.  This has limited use, as there can only
+  be one open handle per process, but implemented in the interests
+  of avoiding unexpected behavior.
+
+
 ## v0.1.1 [2021-03-14] Mahlon E. Smith <mahlon@martini.nu>
 
 Bugfix:

data/README.md

@@ -340,13 +340,6 @@ information about the build environment, the database environment, and
 the currently connected clients.
 
 
-## TODO
-
-  - Expose more database/collection information to statistics
-  - Support libmdbx multiple values per key DUPSORT via `put`, `get`
-    Enumerators, and a 'value' argument for `delete`.
-
-
 ## Contributing
 
 You can check out the current development source with Mercurial via its

data/ext/mdbx_ext/database.c

@@ -1,18 +1,16 @@
-/* vim: set noet sta sw=4 ts=4 : */
-
-#include "mdbx_ext.h"
-
-/* Shortcut for fetching current DB variables.
+/* vim: set noet sta sw=4 ts=4 fdm=marker: */
+/*
+ * Primary database handle functions.
+ *
  */
-#define UNWRAP_DB( val, db ) \
-	rmdbx_db_t *db; \
-	TypedData_Get_Struct( val, rmdbx_db_t, &rmdbx_db_data, db );
 
+#include "mdbx_ext.h"
 
 VALUE rmdbx_cDatabase;
 
+
 /*
- * Ruby allocation hook.
+ * Ruby data allocation wrapper.
  */
 static const rb_data_type_t rmdbx_db_data = {
 	.wrap_struct_name = "MDBX::Database::Data",
@@ -27,11 +25,24 @@ static const rb_data_type_t rmdbx_db_data = {
 VALUE
 rmdbx_alloc( VALUE klass )
 {
-	rmdbx_db_t *new = RB_ALLOC( rmdbx_db_t );
+	rmdbx_db_t *new;
 	return TypedData_Make_Struct( klass, rmdbx_db_t, &rmdbx_db_data, new );
 }
 
 
+/*
+ * Cleanup a previously allocated DB environment.
+ */
+void
+rmdbx_free( void *db )
+{
+	if ( db ) {
+		rmdbx_close_all( db );
+		xfree( db );
+	}
+}
+
+
 /*
  * Ensure all database file descriptors are collected and
  * removed.
@@ -62,19 +73,9 @@ rmdbx_close_dbi( rmdbx_db_t *db )
 
 
 /*
- * Cleanup a previously allocated DB environment.
- */
-void
-rmdbx_free( void *db )
-{
-	if ( db ) {
-		rmdbx_close_all( db );
-		xfree( db );
-	}
-}
-
-
-/*
+ * call-seq:
+ *    db.close => true
+ *
  * Cleanly close an opened database.
  */
 VALUE
@@ -101,17 +102,63 @@ rmdbx_closed_p( VALUE self )
 
 
 /*
- * call-seq:
- *    db.in_transaction? => false
+ * Check if a given +flag+ is enabled for flag +val+.
+ */
+int
+rmdbx_flag_enabled( val, flag )
+{
+	return ( val & flag ) == flag;
+}
+
+
+/*
+ * Given a ruby string +key+ and a pointer to an MDBX_val, prepare the
+ * key for usage within mdbx.  All keys are explicitly converted to
+ * strings.
  *
- * Predicate: return true if a transaction (or snapshot)
- * is currently open.
+ */
+void
+rmdbx_key_for( VALUE key, MDBX_val *ckey )
+{
+	VALUE key_str  = rb_funcall( key, rb_intern("to_s"), 0 );
+	ckey->iov_len  = RSTRING_LEN( key_str );
+	ckey->iov_base = malloc( ckey->iov_len );
+	strlcpy( ckey->iov_base, StringValuePtr(key_str), ckey->iov_len + 1 );
+}
+
+
+/*
+ * Given a ruby +value+ and a pointer to an MDBX_val, prepare
+ * the value for usage within mdbx.  Values are potentially serialized.
+ *
+ */
+void
+rmdbx_val_for( VALUE self, VALUE val, MDBX_val *data )
+{
+	VALUE serialize_proc = rb_iv_get( self, "@serializer" );
+
+	if ( ! NIL_P( serialize_proc ) )
+		val = rb_funcall( serialize_proc, rb_intern("call"), 1, val );
+
+	Check_Type( val, T_STRING );
+
+	data->iov_len  = RSTRING_LEN( val );
+	data->iov_base = malloc( data->iov_len );
+	strlcpy( data->iov_base, StringValuePtr(val), data->iov_len + 1 );
+}
+
+
+/*
+ * Deserialize and return a value.
  */
 VALUE
-rmdbx_in_transaction_p( VALUE self )
+rmdbx_deserialize( VALUE self, VALUE val )
 {
-	UNWRAP_DB( self, db );
-	return db->txn ? Qtrue : Qfalse;
+	VALUE deserialize_proc = rb_iv_get( self, "@deserializer" );
+	if ( ! NIL_P( deserialize_proc ) )
+		val = rb_funcall( deserialize_proc, rb_intern("call"), 1, val );
+
+	return val;
 }
 
 
@@ -148,138 +195,65 @@ rmdbx_open_env( VALUE self )
 		rmdbx_close_all( db );
 		rb_raise( rmdbx_eDatabaseError, "mdbx_env_open: (%d) %s", rc, mdbx_strerror(rc) );
 	}
-	db->state.open = 1;
 
+	db->state.open = 1;
 	return Qtrue;
 }
 
 
-/*
- * Open a cursor for iteration.
- */
-void
-rmdbx_open_cursor( rmdbx_db_t *db )
-{
-	if ( ! db->state.open ) rb_raise( rmdbx_eDatabaseError, "Closed database." );
-	if ( ! db->txn ) rb_raise( rmdbx_eDatabaseError, "No snapshot or transaction currently open." );
-
-	int rc = mdbx_cursor_open( db->txn, db->dbi, &db->cursor );
-	if ( rc != MDBX_SUCCESS ) {
-		rmdbx_close_all( db );
-		rb_raise( rmdbx_eDatabaseError, "Unable to open cursor: (%d) %s", rc, mdbx_strerror(rc) );
-	}
-
-	return;
-}
-
-
-/*
- * Open a new database transaction.  If a transaction is already
- * open, this is a no-op.
- *
- * +rwflag+ must be either MDBX_TXN_RDONLY or MDBX_TXN_READWRITE.
- */
-void
-rmdbx_open_txn( rmdbx_db_t *db, int rwflag )
-{
-	if ( db->txn ) return;
-
-	int rc = mdbx_txn_begin( db->env, NULL, rwflag, &db->txn );
-	if ( rc != MDBX_SUCCESS ) {
-		rmdbx_close_all( db );
-		rb_raise( rmdbx_eDatabaseError, "mdbx_txn_begin: (%d) %s", rc, mdbx_strerror(rc) );
-	}
-
-	if ( db->dbi == 0 ) {
-		// FIXME: dbi_flags
-		rc = mdbx_dbi_open( db->txn, db->subdb, MDBX_CREATE, &db->dbi );
-		if ( rc != MDBX_SUCCESS ) {
-			rmdbx_close_all( db );
-			rb_raise( rmdbx_eDatabaseError, "mdbx_dbi_open: (%d) %s", rc, mdbx_strerror(rc) );
-		}
-	}
-
-	return;
-}
-
-
-/*
- * Close any existing database transaction. If there is no
- * active transaction, this is a no-op.  If there is a long
- * running transaction open, this is a no-op.
- *
- * +txnflag must either be RMDBX_TXN_ROLLBACK or RMDBX_TXN_COMMIT.
- */
-void
-rmdbx_close_txn( rmdbx_db_t *db, int txnflag )
-{
-	if ( ! db->txn || db->state.retain_txn > -1 ) return;
-
-	switch ( txnflag ) {
-		case RMDBX_TXN_COMMIT:
-			mdbx_txn_commit( db->txn );
-		default:
-			mdbx_txn_abort( db->txn );
-	}
-
-	db->txn = 0;
-	return;
-}
-
-
 /*
  * call-seq:
- *    db.open_transaction( mode )
- *
- * Open a new long-running transaction.  If +mode+ is true,
- * it is opened read/write.
+ *    db.clear
  *
+ * Empty the current collection on disk.  If collections are not enabled
+ * or the database handle is set to the top-level (main) db - this
+ * deletes *all records* from the database.
  */
 VALUE
-rmdbx_rb_opentxn( VALUE self, VALUE mode )
+rmdbx_clear( VALUE self )
 {
 	UNWRAP_DB( self, db );
 
-	rmdbx_open_txn( db, RTEST(mode) ? MDBX_TXN_READWRITE : MDBX_TXN_RDONLY );
-	db->state.retain_txn = RTEST(mode) ? 1 : 0;
+	rmdbx_open_txn( db, MDBX_TXN_READWRITE );
+	int rc = mdbx_drop( db->txn, db->dbi, false );
 
-	return Qtrue;
+	if ( rc != MDBX_SUCCESS )
+		rb_raise( rmdbx_eDatabaseError, "mdbx_drop: (%d) %s", rc, mdbx_strerror(rc) );
+
+	rmdbx_close_txn( db, RMDBX_TXN_COMMIT );
+
+	return Qnil;
 }
 
 
 /*
  * call-seq:
- *    db.close_transaction( mode )
- *
- * Close a long-running transaction.  If +write+ is true,
- * the transaction is committed.  Otherwise, rolled back.
+ *    db.drop( collection ) -> db
  *
+ * Destroy a collection.  You must be in the top level database to call
+ * this method.
  */
 VALUE
-rmdbx_rb_closetxn( VALUE self, VALUE write )
+rmdbx_drop( VALUE self, VALUE name )
 {
 	UNWRAP_DB( self, db );
 
-	db->state.retain_txn = -1;
-	rmdbx_close_txn( db, RTEST(write) ? RMDBX_TXN_COMMIT : RMDBX_TXN_ROLLBACK );
+	/* Provide a friendlier error message if max_collections is 0. */
+	if ( db->settings.max_collections == 0 )
+		rb_raise( rmdbx_eDatabaseError, "Unable to drop collection: collections are not enabled." );
 
-	return Qtrue;
-}
+	/* All transactions must be closed when dropping a database. */
+	if ( db->txn )
+		rb_raise( rmdbx_eDatabaseError, "Unable to drop collection: transaction open" );
 
+	/* A drop can only be performed from the top-level database. */
+	if ( db->subdb != NULL )
+		rb_raise( rmdbx_eDatabaseError, "Unable to drop collection: switch to top-level db first" );
 
-/*
- * call-seq:
- *    db.clear
- *
- * Empty the current collection on disk.  If collections are not enabled
- * or the database handle is set to the top-level (main) db - this
- * deletes *all records* from the database.  This is not recoverable!
- */
-VALUE
-rmdbx_clear( VALUE self )
-{
-	UNWRAP_DB( self, db );
+	name = rb_funcall( name, rb_intern("to_s"), 0 );
+	db->subdb = StringValueCStr( name );
 
+	rmdbx_close_dbi( db ); /* ensure we're reopening within the new subdb */
 	rmdbx_open_txn( db, MDBX_TXN_READWRITE );
 	int rc = mdbx_drop( db->txn, db->dbi, true );
 
@@ -288,345 +262,478 @@ rmdbx_clear( VALUE self )
 
 	rmdbx_close_txn( db, RMDBX_TXN_COMMIT );
 
-	/* Refresh the environment handles. */
-	rmdbx_open_env( self );
+	/* Reset the current collection to the top level. */
+	db->subdb = NULL;
+	rmdbx_close_dbi( db ); /* ensure next access is not in the defunct subdb */
 
-	return Qnil;
+	return self;
 }
 
 
-/*
- * Given a ruby +arg+, convert and return a structure
- * suitable for usage as a key for mdbx.  All keys are explicitly
- * converted to strings.
+/* call-seq:
+ *    db.length -> Integer
+ *
+ * Returns the count of keys in the currently selected collection.
  */
-MDBX_val
-rmdbx_key_for( VALUE arg )
+VALUE
+rmdbx_length( VALUE self )
 {
-	MDBX_val rv;
+	UNWRAP_DB( self, db );
+	MDBX_stat mstat;
+
+	CHECK_HANDLE();
+	rmdbx_open_txn( db, MDBX_TXN_RDONLY );
+
+	int rc = mdbx_dbi_stat( db->txn, db->dbi, &mstat, sizeof(mstat) );
+	if ( rc != MDBX_SUCCESS )
+		rb_raise( rmdbx_eDatabaseError, "mdbx_dbi_stat: (%d) %s", rc, mdbx_strerror(rc) );
 
-	arg = rb_funcall( arg, rb_intern("to_s"), 0 );
-	rv.iov_len  = RSTRING_LEN( arg );
-	rv.iov_base = StringValuePtr( arg );
+	VALUE rv = LONG2FIX( mstat.ms_entries );
+	rmdbx_close_txn( db, RMDBX_TXN_ROLLBACK );
 
 	return rv;
 }
 
 
-/*
- * Given a ruby +arg+, convert and return a structure
- * suitable for usage as a value for mdbx.
+/* call-seq:
+ *    db.include?( 'key' ) => bool
+ *
+ * Returns true if the current collection contains +key+.
  */
-MDBX_val
-rmdbx_val_for( VALUE self, VALUE arg )
+VALUE
+rmdbx_include( VALUE self, VALUE key )
 {
-	MDBX_val rv;
-	VALUE serialize_proc;
+	UNWRAP_DB( self, db );
 
-	serialize_proc = rb_iv_get( self, "@serializer" );
-	if ( ! NIL_P( serialize_proc ) )
-		arg = rb_funcall( serialize_proc, rb_intern("call"), 1, arg );
+	CHECK_HANDLE();
+	rmdbx_open_txn( db, MDBX_TXN_RDONLY );
 
-	rv.iov_len  = RSTRING_LEN( arg );
-	rv.iov_base = StringValuePtr( arg );
+	MDBX_val ckey;
+	MDBX_val data;
+	rmdbx_key_for( key, &ckey );
 
-	return rv;
-}
+	int rc = mdbx_get( db->txn, db->dbi, &ckey, &data );
+	rmdbx_close_txn( db, RMDBX_TXN_ROLLBACK );
+	xfree( ckey.iov_base );
 
+	switch ( rc ) {
+		case MDBX_SUCCESS:
+			return Qtrue;
 
-/*
- * Deserialize and return a value.
- */
-VALUE
-rmdbx_deserialize( VALUE self, VALUE val )
-{
-	VALUE deserialize_proc = rb_iv_get( self, "@deserializer" );
-	if ( ! NIL_P( deserialize_proc ) )
-		val = rb_funcall( deserialize_proc, rb_intern("call"), 1, val );
+		case MDBX_NOTFOUND:
+			return Qfalse;
 
-	return val;
+		default:
+			rmdbx_close( self );
+			rb_raise( rmdbx_eDatabaseError, "Unable to fetch key: (%d) %s", rc, mdbx_strerror(rc) );
+	}
 }
 
 
 /* call-seq:
- *    db.each_key {|key| block } => self
+ *    db[ 'key' ] => value
  *
- * Calls the block once for each key, returning self.
- * A transaction must be opened prior to use.
+ * Return a single value for +key+ immediately.
  */
 VALUE
-rmdbx_each_key( VALUE self )
+rmdbx_get_val( VALUE self, VALUE key )
 {
 	UNWRAP_DB( self, db );
-	MDBX_val key, data;
-
-	rmdbx_open_cursor( db );
-	RETURN_ENUMERATOR( self, 0, 0 );
 
-	if ( mdbx_cursor_get( db->cursor, &key, &data, MDBX_FIRST ) == MDBX_SUCCESS ) {
-		rb_yield( rb_str_new( key.iov_base, key.iov_len ) );
-		while ( mdbx_cursor_get( db->cursor, &key, &data, MDBX_NEXT ) == MDBX_SUCCESS ) {
-			rb_yield( rb_str_new( key.iov_base, key.iov_len ) );
-		}
-	}
+	CHECK_HANDLE();
+	rmdbx_open_txn( db, MDBX_TXN_RDONLY );
 
-	mdbx_cursor_close( db->cursor );
-	db->cursor = NULL;
-	return self;
-}
+	MDBX_val ckey;
+	MDBX_val data;
 
+	rmdbx_key_for( key, &ckey );
+	int rc = mdbx_get( db->txn, db->dbi, &ckey, &data );
+	rmdbx_close_txn( db, RMDBX_TXN_ROLLBACK );
+	xfree( ckey.iov_base );
 
-/* call-seq:
- *    db.each_value {|value| block } => self
+	VALUE rv;
+	switch ( rc ) {
+		case MDBX_SUCCESS:
+			rv = rb_str_new( data.iov_base, data.iov_len );
+			return rmdbx_deserialize( self, rv );
+
+		case MDBX_NOTFOUND:
+			return Qnil;
+
+		default:
+			rmdbx_close( self );
+			rb_raise( rmdbx_eDatabaseError, "Unable to fetch value: (%d) %s", rc, mdbx_strerror(rc) );
+	}
+}
+
+
+/* call-seq:
+ *    db[ 'key' ] = value
  *
- * Calls the block once for each value, returning self.
- * A transaction must be opened prior to use.
+ * Set a single value for +key+.  If the value is +nil+, the
+ * key is removed.
  */
 VALUE
-rmdbx_each_value( VALUE self )
+rmdbx_put_val( VALUE self, VALUE key, VALUE val )
 {
+	int rc;
 	UNWRAP_DB( self, db );
-	MDBX_val key, data;
 
-	rmdbx_open_cursor( db );
-	RETURN_ENUMERATOR( self, 0, 0 );
+	CHECK_HANDLE();
+	rmdbx_open_txn( db, MDBX_TXN_READWRITE );
 
-	if ( mdbx_cursor_get( db->cursor, &key, &data, MDBX_FIRST ) == MDBX_SUCCESS ) {
-		VALUE rv = rb_str_new( data.iov_base, data.iov_len );
-		rb_yield( rmdbx_deserialize( self, rv ) );
+	MDBX_val ckey;
+	rmdbx_key_for( key, &ckey );
 
-		while ( mdbx_cursor_get( db->cursor, &key, &data, MDBX_NEXT ) == MDBX_SUCCESS ) {
-			rv = rb_str_new( data.iov_base, data.iov_len );
-			rb_yield( rmdbx_deserialize( self, rv ) );
-		}
+	if ( NIL_P(val) ) { /* remove if set to nil */
+		rc = mdbx_del( db->txn, db->dbi, &ckey, NULL );
+	}
+	else {
+		MDBX_val old;
+		MDBX_val data;
+		rmdbx_val_for( self, val, &data );
+		rc = mdbx_replace( db->txn, db->dbi, &ckey, &data, &old, 0 );
+		xfree( data.iov_base );
 	}
 
-	mdbx_cursor_close( db->cursor );
-	db->cursor = NULL;
-	return self;
+	rmdbx_close_txn( db, RMDBX_TXN_COMMIT );
+	xfree( ckey.iov_base );
+
+	switch ( rc ) {
+		case MDBX_SUCCESS:
+			return val;
+		case MDBX_NOTFOUND:
+			return Qnil;
+		default:
+			rb_raise( rmdbx_eDatabaseError, "Unable to update value: (%d) %s", rc, mdbx_strerror(rc) );
+	}
 }
 
 
-/* call-seq:
- *    db.each_pair {|key, value| block } => self
+/*
+ * Return the currently selected collection, or +nil+ if at the
+ * top-level.
+ */
+VALUE
+rmdbx_get_subdb( VALUE self )
+{
+	UNWRAP_DB( self, db );
+	return ( db->subdb == NULL ) ? Qnil : rb_str_new_cstr( db->subdb );
+}
+
+
+/*
+ * Sets the current collection name for read/write operations.
  *
- * Calls the block once for each key and value, returning self.
- * A transaction must be opened prior to use.
  */
 VALUE
-rmdbx_each_pair( VALUE self )
+rmdbx_set_subdb( VALUE self, VALUE name )
 {
 	UNWRAP_DB( self, db );
-	MDBX_val key, data;
 
-	rmdbx_open_cursor( db );
-	RETURN_ENUMERATOR( self, 0, 0 );
+	/* Provide a friendlier error message if max_collections is 0. */
+	if ( db->settings.max_collections == 0 )
+		rb_raise( rmdbx_eDatabaseError, "Unable to change collection: collections are not enabled." );
 
-	if ( mdbx_cursor_get( db->cursor, &key, &data, MDBX_FIRST ) == MDBX_SUCCESS ) {
-		VALUE rkey = rb_str_new( key.iov_base, key.iov_len );
-		VALUE rval = rb_str_new( data.iov_base, data.iov_len );
-		rb_yield( rb_assoc_new( rkey, rmdbx_deserialize( self, rval ) ) );
+	/* All transactions must be closed when switching database handles. */
+	if ( db->txn )
+		rb_raise( rmdbx_eDatabaseError, "Unable to change collection: transaction open" );
 
-		while ( mdbx_cursor_get( db->cursor, &key, &data, MDBX_NEXT ) == MDBX_SUCCESS ) {
-			rkey = rb_str_new( key.iov_base, key.iov_len );
-			rval = rb_str_new( data.iov_base, data.iov_len );
-			rb_yield( rb_assoc_new( rkey, rmdbx_deserialize( self, rval ) ) );
-		}
+	xfree( db->subdb ); 
+	db->subdb = NULL;
+
+	if ( ! NIL_P(name) ) {
+		size_t len = RSTRING_LEN( name ) + 1;
+		db->subdb = malloc( len );
+		strlcpy( db->subdb, StringValuePtr(name), len );
 	}
 
-	mdbx_cursor_close( db->cursor );
-	db->cursor = NULL;
+	/* Reset the db handle and issue a single transaction to reify
+	   the collection.
+	*/
+	rmdbx_close_dbi( db );
+	rmdbx_open_txn( db, MDBX_TXN_READWRITE );
+	rmdbx_close_txn( db, RMDBX_TXN_COMMIT );
+
 	return self;
 }
 
 
-/* call-seq:
- *    db.length -> Integer
+/*
+ * call-seq:
+ *    db.in_transaction? => false
  *
- * Returns the count of keys in the currently selected collection.
+ * Predicate: return true if a transaction (or snapshot)
+ * is currently open.
  */
 VALUE
-rmdbx_length( VALUE self )
+rmdbx_in_transaction_p( VALUE self )
 {
 	UNWRAP_DB( self, db );
-	MDBX_stat mstat;
+	return db->txn ? Qtrue : Qfalse;
+}
 
-	if ( ! db->state.open ) rb_raise( rmdbx_eDatabaseError, "Closed database." );
-	rmdbx_open_txn( db, MDBX_TXN_RDONLY );
 
-	int rc = mdbx_dbi_stat( db->txn, db->dbi, &mstat, sizeof(mstat) );
-	if ( rc != MDBX_SUCCESS )
-		rb_raise( rmdbx_eDatabaseError, "mdbx_dbi_stat: (%d) %s", rc, mdbx_strerror(rc) );
+/*
+ * Open a new database transaction.  If a transaction is already
+ * open, this is a no-op.
+ *
+ * +rwflag+ must be either MDBX_TXN_RDONLY or MDBX_TXN_READWRITE.
+ */
+void
+rmdbx_open_txn( rmdbx_db_t *db, int rwflag )
+{
+	if ( db->txn ) return;
 
-	VALUE rv = LONG2FIX( mstat.ms_entries );
-	rmdbx_close_txn( db, RMDBX_TXN_ROLLBACK );
+	int rc = mdbx_txn_begin( db->env, NULL, rwflag, &db->txn );
+	if ( rc != MDBX_SUCCESS ) {
+		rmdbx_close_all( db );
+		rb_raise( rmdbx_eDatabaseError, "mdbx_txn_begin: (%d) %s", rc, mdbx_strerror(rc) );
+	}
 
-	return rv;
+	if ( db->dbi == 0 ) {
+		rc = mdbx_dbi_open( db->txn, db->subdb, db->settings.db_flags, &db->dbi );
+		if ( rc != MDBX_SUCCESS ) {
+			rmdbx_close_all( db );
+			rb_raise( rmdbx_eDatabaseError, "mdbx_dbi_open: (%d) %s", rc, mdbx_strerror(rc) );
+		}
+	}
+
+	return;
 }
 
 
-/* call-seq:
- *    db[ 'key' ] => value
+/*
+ * Close any existing database transaction. If there is no
+ * active transaction, this is a no-op.  If there is a long
+ * running transaction open, this is a no-op.
+ *
+ * +txnflag must either be RMDBX_TXN_ROLLBACK or RMDBX_TXN_COMMIT.
+ */
+void
+rmdbx_close_txn( rmdbx_db_t *db, int txnflag )
+{
+	if ( ! db->txn || db->state.retain_txn > -1 ) return;
+
+	if ( txnflag == RMDBX_TXN_COMMIT ) {
+		mdbx_txn_commit( db->txn );
+	}
+	else {
+		mdbx_txn_abort( db->txn );
+	}
+
+	db->txn = 0;
+	return;
+}
+
+
+/*
+ * call-seq:
+ *    db.open_transaction( mode )
+ *
+ * Open a new long-running transaction.  If +mode+ is true,
+ * it is opened read/write.
  *
- * Return a single value for +key+ immediately.
  */
 VALUE
-rmdbx_get_val( VALUE self, VALUE key )
+rmdbx_rb_opentxn( VALUE self, VALUE mode )
 {
-	int rc;
 	UNWRAP_DB( self, db );
+	CHECK_HANDLE();
 
-	if ( ! db->state.open ) rb_raise( rmdbx_eDatabaseError, "Closed database." );
-	rmdbx_open_txn( db, MDBX_TXN_RDONLY );
+	rmdbx_open_txn( db, RTEST(mode) ? MDBX_TXN_READWRITE : MDBX_TXN_RDONLY );
+	db->state.retain_txn = RTEST(mode) ? 1 : 0;
 
-	MDBX_val ckey = rmdbx_key_for( key );
-	MDBX_val data;
-	VALUE rv;
-	rc = mdbx_get( db->txn, db->dbi, &ckey, &data );
-	rmdbx_close_txn( db, RMDBX_TXN_ROLLBACK );
+	return Qtrue;
+}
 
-	switch ( rc ) {
-		case MDBX_SUCCESS:
-			rv = rb_str_new( data.iov_base, data.iov_len );
-			return rmdbx_deserialize( self, rv );
 
-		case MDBX_NOTFOUND:
-			return Qnil;
+/*
+ * call-seq:
+ *    db.close_transaction( mode )
+ *
+ * Close a long-running transaction.  If +write+ is true,
+ * the transaction is committed.  Otherwise, rolled back.
+ *
+ */
+VALUE
+rmdbx_rb_closetxn( VALUE self, VALUE write )
+{
+	UNWRAP_DB( self, db );
 
-		default:
-			rmdbx_close( self );
-			rb_raise( rmdbx_eDatabaseError, "Unable to fetch value: (%d) %s", rc, mdbx_strerror(rc) );
+	db->state.retain_txn = -1;
+	rmdbx_close_txn( db, RTEST(write) ? RMDBX_TXN_COMMIT : RMDBX_TXN_ROLLBACK );
+
+	return Qtrue;
+}
+
+
+/*
+ * Open a cursor for iteration.
+ */
+void
+rmdbx_open_cursor( rmdbx_db_t *db )
+{
+	CHECK_HANDLE();
+	if ( ! db->txn ) rb_raise( rmdbx_eDatabaseError, "No snapshot or transaction currently open." );
+
+	int rc = mdbx_cursor_open( db->txn, db->dbi, &db->cursor );
+	if ( rc != MDBX_SUCCESS ) {
+		rmdbx_close_all( db );
+		rb_raise( rmdbx_eDatabaseError, "Unable to open cursor: (%d) %s", rc, mdbx_strerror(rc) );
 	}
+
+	return;
+}
+
+
+/*
+ * Enumerate over keys for the current collection.
+ */
+VALUE
+rmdbx_each_key_i( VALUE self )
+{
+	UNWRAP_DB( self, db );
+	MDBX_val key, data;
+
+	if ( mdbx_cursor_get( db->cursor, &key, &data, MDBX_FIRST ) == MDBX_SUCCESS ) {
+		rb_yield( rb_str_new( key.iov_base, key.iov_len ) );
+		while ( mdbx_cursor_get( db->cursor, &key, &data, MDBX_NEXT ) == MDBX_SUCCESS ) {
+			rb_yield( rb_str_new( key.iov_base, key.iov_len ) );
+		}
+	}
+
+	return self;
 }
 
 
 /* call-seq:
- *    db[ 'key' ] = value
+ *    db.each_key {|key| block } => self
  *
- * Set a single value for +key+.
+ * Calls the block once for each key, returning self.
+ * A transaction must be opened prior to use.
  */
 VALUE
-rmdbx_put_val( VALUE self, VALUE key, VALUE val )
+rmdbx_each_key( VALUE self )
 {
-	int rc;
 	UNWRAP_DB( self, db );
+	int state;
 
-	if ( ! db->state.open ) rb_raise( rmdbx_eDatabaseError, "Closed database." );
-	rmdbx_open_txn( db, MDBX_TXN_READWRITE );
+	CHECK_HANDLE();
+	rmdbx_open_cursor( db );
+	RETURN_ENUMERATOR( self, 0, 0 );
 
-	MDBX_val ckey = rmdbx_key_for( key );
+	rb_protect( rmdbx_each_key_i, self, &state );
 
-	// FIXME: DUPSORT is enabled -- different api?
-	// See:  MDBX_NODUPDATA / MDBX_NOOVERWRITE
-	if ( NIL_P(val) ) { /* remove if set to nil */
-		rc = mdbx_del( db->txn, db->dbi, &ckey, NULL );
-	}
-	else {
-		MDBX_val old;
-		MDBX_val data = rmdbx_val_for( self, val );
-		rc = mdbx_replace( db->txn, db->dbi, &ckey, &data, &old, 0 );
-	}
+	mdbx_cursor_close( db->cursor );
+	db->cursor = NULL;
 
-	rmdbx_close_txn( db, RMDBX_TXN_COMMIT );
+	if ( state ) rb_jump_tag( state );
 
-	switch ( rc ) {
-		case MDBX_SUCCESS:
-			return val;
-		case MDBX_NOTFOUND:
-			return Qnil;
-		default:
-			rb_raise( rmdbx_eDatabaseError, "Unable to store value: (%d) %s", rc, mdbx_strerror(rc) );
-	}
+	return self;
 }
 
 
-/*
- * call-seq:
- *    db.statistics => (hash of stats)
- *
- * Returns a hash populated with various metadata for the opened
- * database.
- *
+/* Enumerate over values for the current collection.
  */
 VALUE
-rmdbx_stats( VALUE self )
+rmdbx_each_value_i( VALUE self )
 {
 	UNWRAP_DB( self, db );
-	if ( ! db->state.open ) rb_raise( rmdbx_eDatabaseError, "Closed database." );
+	MDBX_val key, data;
 
-	return rmdbx_gather_stats( db );
+	if ( mdbx_cursor_get( db->cursor, &key, &data, MDBX_FIRST ) == MDBX_SUCCESS ) {
+		VALUE rv = rb_str_new( data.iov_base, data.iov_len );
+		rb_yield( rmdbx_deserialize( self, rv ) );
+
+		while ( mdbx_cursor_get( db->cursor, &key, &data, MDBX_NEXT ) == MDBX_SUCCESS ) {
+			rv = rb_str_new( data.iov_base, data.iov_len );
+			rb_yield( rmdbx_deserialize( self, rv ) );
+		}
+	}
+
+	return self;
 }
 
 
-/*
- * call-seq:
- *    db.collection -> (collection name, or nil if in main)
- *    db.collection( 'collection_name' ) -> db
- *    db.collection( nil ) -> db (main)
- *
- * Gets or sets the sub-database "collection" that read/write
- * operations apply to.
- * Passing +nil+ sets the database to the main, top-level namespace.
- * If a block is passed, the collection automatically reverts to the
- * prior collection when it exits.
- *
- *    db.collection( 'collection_name' ) do
- *        [ ... ]
- *    end # reverts to the previous collection name
+/* call-seq:
+ *    db.each_value {|value| block } => self
  *
+ * Calls the block once for each value, returning self.
+ * A transaction must be opened prior to use.
  */
 VALUE
-rmdbx_set_subdb( int argc, VALUE *argv, VALUE self )
+rmdbx_each_value( VALUE self )
 {
 	UNWRAP_DB( self, db );
-	VALUE subdb, block;
-	char *prev_db = NULL;
+	int state;
 
-	rb_scan_args( argc, argv, "01&", &subdb, &block );
-	if ( argc == 0 ) {
-		if ( db->subdb == NULL ) return Qnil;
-		return rb_str_new_cstr( db->subdb );
-	}
+	CHECK_HANDLE();
+	rmdbx_open_cursor( db );
+	RETURN_ENUMERATOR( self, 0, 0 );
 
-	/* Provide a friendlier error message if max_collections is 0. */
-	if ( db->settings.max_collections == 0 )
-		rb_raise( rmdbx_eDatabaseError, "Unable to change collection: collections are not enabled." );
+	rb_protect( rmdbx_each_value_i, self, &state );
 
-	/* All transactions must be closed when switching database handles. */
-	if ( db->txn )
-		rb_raise( rmdbx_eDatabaseError, "Unable to change collection: transaction open" );
+	mdbx_cursor_close( db->cursor );
+	db->cursor = NULL;
 
-	/* Retain the prior database collection if a block was passed.
-	 */
-	if ( rb_block_given_p() && db->subdb != NULL ) {
-		prev_db = (char *) malloc( strlen(db->subdb) + 1 );
-		strcpy( prev_db, db->subdb );
-	}
+	if ( state ) rb_jump_tag( state );
 
-	db->subdb = NIL_P( subdb ) ? NULL : StringValueCStr( subdb );
-	rmdbx_close_dbi( db );
+	return self;
+}
 
-	/*
-	  FIXME:  Immediate transaction write to auto-create new env?
-	  Fetching from here at the moment causes an error if you
-	  haven't written anything to the new collection yet.
-	 */
 
-	/* Revert to the previous collection after the block is done.
-	 */
-	if ( rb_block_given_p() ) {
-		rb_yield( self );
-		if ( db->subdb != prev_db ) {
-			db->subdb = prev_db;
-			rmdbx_close_dbi( db );
+/* Enumerate over key and value pairs for the current collection.
+ */
+VALUE
+rmdbx_each_pair_i( VALUE self )
+{
+	UNWRAP_DB( self, db );
+	MDBX_val key, data;
+
+	if ( mdbx_cursor_get( db->cursor, &key, &data, MDBX_FIRST ) == MDBX_SUCCESS ) {
+		VALUE rkey = rb_str_new( key.iov_base, key.iov_len );
+		VALUE rval = rb_str_new( data.iov_base, data.iov_len );
+		rb_yield( rb_assoc_new( rkey, rmdbx_deserialize( self, rval ) ) );
+
+		while ( mdbx_cursor_get( db->cursor, &key, &data, MDBX_NEXT ) == MDBX_SUCCESS ) {
+			rkey = rb_str_new( key.iov_base, key.iov_len );
+			rval = rb_str_new( data.iov_base, data.iov_len );
+			rb_yield( rb_assoc_new( rkey, rmdbx_deserialize( self, rval ) ) );
 		}
-		xfree( prev_db );
 	}
 
 	return self;
 }
 
 
+/* call-seq:
+ *    db.each_pair {|key, value| block } => self
+ *
+ * Calls the block once for each key and value, returning self.
+ * A transaction must be opened prior to use.
+ */
+VALUE
+rmdbx_each_pair( VALUE self )
+{
+	UNWRAP_DB( self, db );
+	int state;
+
+	CHECK_HANDLE();
+	rmdbx_open_cursor( db );
+	RETURN_ENUMERATOR( self, 0, 0 );
+
+	rb_protect( rmdbx_each_pair_i, self, &state );
+
+	mdbx_cursor_close( db->cursor );
+	db->cursor = NULL;
+
+	if ( state ) rb_jump_tag( state );
+
+	return self;
+}
+
+
 /*
  * Open an existing (or create a new) mdbx database at filesystem
  * +path+.  In block form, the database is automatically closed.
@@ -666,57 +773,108 @@ rmdbx_database_initialize( int argc, VALUE *argv, VALUE self )
 	db->state.open       = 0;
 	db->state.retain_txn = -1;
 	db->settings.env_flags       = MDBX_ENV_DEFAULTS;
+	db->settings.db_flags        = MDBX_DB_DEFAULTS | MDBX_CREATE;
 	db->settings.mode            = 0644;
 	db->settings.max_collections = 0;
 	db->settings.max_readers     = 0;
 	db->settings.max_size        = 0;
 
-	/* Options setup, overrides.
+	/* Set instance variables.
 	 */
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("mode") ) );
-	if ( ! NIL_P(opt) ) db->settings.mode = FIX2INT( opt );
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("max_collections") ) );
+	rb_iv_set( self, "@path", path );
+	rb_iv_set( self, "@options", rb_hash_dup( opts ) );
+
+	/* Environment and database options setup, overrides.
+	 */
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("coalesce") ) );
+	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_COALESCE;
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("compatible") ) );
+	if ( RTEST(opt) ) {
+		db->settings.db_flags  = db->settings.db_flags | MDBX_DB_ACCEDE;
+		db->settings.env_flags = db->settings.env_flags | MDBX_ACCEDE;
+	}
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("exclusive") ) );
+	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_EXCLUSIVE;
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("lifo_reclaim") ) );
+	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_LIFORECLAIM;
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("max_collections") ) );
 	if ( ! NIL_P(opt) ) db->settings.max_collections = FIX2INT( opt );
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("max_readers") ) );
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("max_readers") ) );
 	if ( ! NIL_P(opt) ) db->settings.max_readers = FIX2INT( opt );
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("max_size") ) );
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("max_size") ) );
 	if ( ! NIL_P(opt) ) db->settings.max_size = NUM2LONG( opt );
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("nosubdir") ) );
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("mode") ) );
+	if ( ! NIL_P(opt) ) db->settings.mode = FIX2INT( opt );
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("no_memory_init") ) );
+	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_NOMEMINIT;
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("no_metasync") ) );
+	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_NOMETASYNC;
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("no_subdir") ) );
 	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_NOSUBDIR;
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("readonly") ) );
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("no_readahead") ) );
+	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_NORDAHEAD;
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("no_threadlocal") ) );
+	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_NOTLS;
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("readonly") ) );
 	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_RDONLY;
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("exclusive") ) );
-	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_EXCLUSIVE;
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("compat") ) );
-	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_ACCEDE;
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("writemap") ) );
+	opt = rb_hash_delete( opts, ID2SYM( rb_intern("writemap") ) );
 	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_WRITEMAP;
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("no_threadlocal") ) );
-	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_NOTLS;
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("no_readahead") ) );
-	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_NORDAHEAD;
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("no_memory_init") ) );
-	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_NOMEMINIT;
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("coalesce") ) );
-	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_COALESCE;
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("lifo_reclaim") ) );
-	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_LIFORECLAIM;
-	opt = rb_hash_aref( opts, ID2SYM( rb_intern("no_metasync") ) );
-	if ( RTEST(opt) ) db->settings.env_flags = db->settings.env_flags | MDBX_NOMETASYNC;
 
-	/* Duplicate keys, on mdbx_dbi_open, maybe set here? */
-	/* MDBX_DUPSORT = UINT32_C(0x04), */
-
-	/* Set instance variables.
-	 */
-	rb_iv_set( self, "@path", path );
-	rb_iv_set( self, "@options", opts );
+	if ( rb_hash_size_num(opts) > 0 ) {
+		rb_raise( rb_eArgError, "Unknown option(s): %"PRIsVALUE, opts );
+	}
 
 	rmdbx_open_env( self );
 	return self;
 }
 
 
+/*
+ * call-seq:
+ *    db.statistics => (hash of stats)
+ *
+ * Returns a hash populated with various metadata for the opened
+ * database.
+ *
+ */
+VALUE
+rmdbx_stats( VALUE self )
+{
+	UNWRAP_DB( self, db );
+	CHECK_HANDLE();
+
+	return rmdbx_gather_stats( db );
+}
+
+
+/*
+ * call-seq:
+ *    db.clone => [copy of db]
+ *
+ * Copy the object (clone/dup).  The returned copy is closed and needs
+ * to be reopened before use.  This function likely  has limited use,
+ * considering you can't open two handles within the same process.
+ */
+static VALUE rmdbx_init_copy( VALUE copy, VALUE orig )
+{
+	rmdbx_db_t *orig_db;
+	rmdbx_db_t *copy_db;
+
+	if ( copy == orig ) return copy;
+
+	TypedData_Get_Struct( orig, rmdbx_db_t, &rmdbx_db_data, orig_db );
+	TypedData_Get_Struct( copy, rmdbx_db_t, &rmdbx_db_data, copy_db );
+
+	/* Copy all fields from the original to the copy, and force-close
+	   the copy.
+	*/
+	MEMCPY( copy_db, orig_db, rmdbx_db_t, 1 );
+	rmdbx_close_all( copy_db );
+
+	return copy;
+}
+
+
 /*
  * Initialization for the MDBX::Database class.
  */
@@ -732,25 +890,35 @@ rmdbx_init_database()
 	rb_define_alloc_func( rmdbx_cDatabase, rmdbx_alloc );
 
 	rb_define_protected_method( rmdbx_cDatabase, "initialize", rmdbx_database_initialize, -1 );
-	rb_define_method( rmdbx_cDatabase, "collection", rmdbx_set_subdb, -1 );
+	rb_define_protected_method( rmdbx_cDatabase, "initialize_copy", rmdbx_init_copy, 1 );
+
+	rb_define_method( rmdbx_cDatabase, "clear", rmdbx_clear, 0 );
 	rb_define_method( rmdbx_cDatabase, "close", rmdbx_close, 0 );
-	rb_define_method( rmdbx_cDatabase, "reopen", rmdbx_open_env, 0 );
 	rb_define_method( rmdbx_cDatabase, "closed?", rmdbx_closed_p, 0 );
-	rb_define_method( rmdbx_cDatabase, "in_transaction?", rmdbx_in_transaction_p, 0 );
-	rb_define_method( rmdbx_cDatabase, "clear", rmdbx_clear, 0 );
-	rb_define_method( rmdbx_cDatabase, "each_key", rmdbx_each_key, 0 );
-	rb_define_method( rmdbx_cDatabase, "each_value", rmdbx_each_value, 0 );
-	rb_define_method( rmdbx_cDatabase, "each_pair", rmdbx_each_pair, 0 );
+	rb_define_method( rmdbx_cDatabase, "drop", rmdbx_drop, 1 );
+	rb_define_method( rmdbx_cDatabase, "include?", rmdbx_include, 1 );
 	rb_define_method( rmdbx_cDatabase, "length", rmdbx_length, 0 );
+	rb_define_method( rmdbx_cDatabase, "reopen", rmdbx_open_env, 0 );
 	rb_define_method( rmdbx_cDatabase, "[]", rmdbx_get_val, 1 );
 	rb_define_method( rmdbx_cDatabase, "[]=", rmdbx_put_val, 2 );
 
+	/* Enumerables */
+	rb_define_method( rmdbx_cDatabase, "each_key", rmdbx_each_key, 0 );
+	rb_define_method( rmdbx_cDatabase, "each_pair", rmdbx_each_pair, 0 );
+	rb_define_method( rmdbx_cDatabase, "each_value", rmdbx_each_value, 0 );
+
 	/* Manually open/close transactions from ruby. */
+	rb_define_method( rmdbx_cDatabase, "in_transaction?", rmdbx_in_transaction_p, 0 );
 	rb_define_protected_method( rmdbx_cDatabase, "open_transaction",  rmdbx_rb_opentxn, 1 );
 	rb_define_protected_method( rmdbx_cDatabase, "close_transaction", rmdbx_rb_closetxn, 1 );
 
+	/* Collection functions */
+	rb_define_protected_method( rmdbx_cDatabase, "get_subdb", rmdbx_get_subdb, 0 );
+	rb_define_protected_method( rmdbx_cDatabase, "set_subdb", rmdbx_set_subdb, 1 );
+
 	rb_define_protected_method( rmdbx_cDatabase, "raw_stats", rmdbx_stats, 0 );
 
 	rb_require( "mdbx/database" );
 }
 
+