Introduce static_write_txn

Author: Paraworker

heed/src/envs/encrypted_env.rs

@@ -176,6 +176,8 @@ impl<T> EncryptedEnv<T> {
 
     /// Create a transaction with read and write access for use with the environment.
     ///
+    /// See [`Self::static_write_txn`] if you want the txn to own the environment.
+    ///
     /// ## LMDB Limitations
     ///
     /// Only one [`RwTxn`] may exist simultaneously in the current environment.
@@ -186,6 +188,20 @@ impl<T> EncryptedEnv<T> {
         self.inner.write_txn()
     }
 
+    /// Create a transaction with read and write access for use with the environment.
+    /// Contrary to [`Self::write_txn`], this version **owns** the environment, which
+    /// means you won't be able to close the environment while this transaction is alive.
+    ///
+    /// ## LMDB Limitations
+    ///
+    /// Only one [`RwTxn`] may exist simultaneously in the current environment.
+    /// If another write transaction is initiated, while another write transaction exists
+    /// the thread initiating the new one will wait on a mutex upon completion of the previous
+    /// transaction.
+    pub fn static_write_txn(self) -> Result<RwTxn<'static>> {
+        self.inner.static_write_txn()
+    }
+
     /// Create a nested transaction with read and write access for use with the environment.
     ///
     /// The new transaction will be a nested transaction, with the transaction indicated by parent

heed/src/envs/env.rs

@@ -374,6 +374,8 @@ impl<T> Env<T> {
 
     /// Create a transaction with read and write access for use with the environment.
     ///
+    /// See [`Self::static_write_txn`] if you want the txn to own the environment.
+    ///
     /// ## LMDB Limitations
     ///
     /// Only one [`RwTxn`] may exist simultaneously in the current environment.
@@ -384,6 +386,20 @@ impl<T> Env<T> {
         RwTxn::new(self)
     }
 
+    /// Create a transaction with read and write access for use with the environment.
+    /// Contrary to [`Self::write_txn`], this version **owns** the environment, which
+    /// means you won't be able to close the environment while this transaction is alive.
+    ///
+    /// ## LMDB Limitations
+    ///
+    /// Only one [`RwTxn`] may exist simultaneously in the current environment.
+    /// If another write transaction is initiated, while another write transaction exists
+    /// the thread initiating the new one will wait on a mutex upon completion of the previous
+    /// transaction.
+    pub fn static_write_txn(self) -> Result<RwTxn<'static>> {
+        RwTxn::static_write_txn(self)
+    }
+
     /// Create a nested transaction with read and write access for use with the environment.
     ///
     /// The new transaction will be a nested transaction, with the transaction indicated by parent

heed/src/txn.rs

@@ -298,6 +298,26 @@ impl<'p> RwTxn<'p> {
         })
     }
 
+    pub(crate) fn static_write_txn<T>(env: Env<T>) -> Result<RwTxn<'static>> {
+        let mut txn: *mut ffi::MDB_txn = ptr::null_mut();
+
+        unsafe {
+            mdb_result(ffi::mdb_txn_begin(
+                env.env_mut_ptr().as_mut(),
+                ptr::null_mut(),
+                0,
+                &mut txn,
+            ))?
+        };
+
+        Ok(RwTxn {
+            txn: RoTxn {
+                inner: RoTxnInner { txn: NonNull::new(txn), env: Cow::Owned(env.inner) },
+                _tls_marker: PhantomData,
+            },
+        })
+    }
+
     pub(crate) fn nested<T>(env: &'p Env<T>, parent: &'p mut RwTxn) -> Result<RwTxn<'p>> {
         let mut txn: *mut ffi::MDB_txn = ptr::null_mut();
         let parent_ptr: *mut ffi::MDB_txn = unsafe { parent.txn.inner.txn.unwrap().as_mut() };