Add lifetimes to the PolyDatabase and Database types

heed/src/db/database.rs

@@ -114,13 +114,13 @@ use crate::*;
 /// wtxn.commit()?;
 /// # Ok(()) }
 /// ```
-pub struct Database<KC, DC> {
-    pub(crate) dyndb: PolyDatabase,
-    marker: marker::PhantomData<(KC, DC)>,
+pub struct Database<'t, KC, DC> {
+    pub(crate) dyndb: PolyDatabase<'t>,
+    pub(crate) marker: marker::PhantomData<(KC, DC)>,
 }
 
-impl<KC, DC> Database<KC, DC> {
-    pub(crate) fn new(env_ident: usize, dbi: ffi::MDB_dbi) -> Database<KC, DC> {
+impl<KC, DC> Database<'_, KC, DC> {
+    pub(crate) fn new<'t>(env_ident: usize, dbi: ffi::MDB_dbi) -> Database<'t, KC, DC> {
         Database { dyndb: PolyDatabase::new(env_ident, dbi), marker: std::marker::PhantomData }
     }
 
@@ -1604,15 +1604,15 @@ impl<KC, DC> Database<KC, DC> {
     }
 }
 
-impl<KC, DC> Clone for Database<KC, DC> {
-    fn clone(&self) -> Database<KC, DC> {
+impl<'t, KC, DC> Clone for Database<'t, KC, DC> {
+    fn clone(&self) -> Database<'t, KC, DC> {
         Database { dyndb: self.dyndb, marker: marker::PhantomData }
     }
 }
 
-impl<KC, DC> Copy for Database<KC, DC> {}
+impl<KC, DC> Copy for Database<'_, KC, DC> {}
 
-impl<KC, DC> fmt::Debug for Database<KC, DC> {
+impl<KC, DC> fmt::Debug for Database<'_, KC, DC> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("Database")
             .field("key_codec", &any::type_name::<KC>())

heed/src/db/poly_database.rs

@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 use std::ops::{Bound, RangeBounds};
-use std::{fmt, mem, ptr};
+use std::{fmt, marker, mem, ptr};
 
 use crate::mdb::error::mdb_result;
 use crate::mdb::ffi;
@@ -103,14 +103,15 @@ use crate::*;
 /// # Ok(()) }
 /// ```
 #[derive(Copy, Clone)]
-pub struct PolyDatabase {
+pub struct PolyDatabase<'t> {
     pub(crate) env_ident: usize,
+    pub(crate) txn: marker::PhantomData<&'t ()>,
     pub(crate) dbi: ffi::MDB_dbi,
 }
 
-impl PolyDatabase {
-    pub(crate) fn new(env_ident: usize, dbi: ffi::MDB_dbi) -> PolyDatabase {
-        PolyDatabase { env_ident, dbi }
+impl PolyDatabase<'_> {
+    pub(crate) fn new<'t>(env_ident: usize, dbi: ffi::MDB_dbi) -> PolyDatabase<'t> {
+        PolyDatabase { env_ident, txn: marker::PhantomData, dbi }
     }
 
     /// Retrieves the value associated with a key.
@@ -1856,7 +1857,7 @@ impl PolyDatabase {
     }
 }
 
-impl fmt::Debug for PolyDatabase {
+impl fmt::Debug for PolyDatabase<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("PolyDatabase").finish()
     }

heed/src/env.rs

@@ -449,11 +449,11 @@ impl Env {
     /// LMDB have an important restriction on the unnamed database when named ones are opened,
     /// the names of the named databases are stored as keys in the unnamed one and are immutable,
     /// these keys can only be read and not written.
-    pub fn open_database<KC, DC>(
+    pub fn open_database<'t, KC, DC>(
         &self,
-        rtxn: &RoTxn,
+        rtxn: &'t RoTxn,
         name: Option<&str>,
-    ) -> Result<Option<Database<KC, DC>>>
+    ) -> Result<Option<Database<'t, KC, DC>>>
     where
         KC: 'static,
         DC: 'static,
@@ -477,11 +477,11 @@ impl Env {
     /// LMDB have an important restriction on the unnamed database when named ones are opened,
     /// the names of the named databases are stored as keys in the unnamed one and are immutable,
     /// these keys can only be read and not written.
-    pub fn open_poly_database(
+    pub fn open_poly_database<'t>(
         &self,
-        rtxn: &RoTxn,
+        rtxn: &'t RoTxn,
         name: Option<&str>,
-    ) -> Result<Option<PolyDatabase>> {
+    ) -> Result<Option<PolyDatabase<'t>>> {
         assert_eq_env_txn!(self, rtxn);
 
         match self.raw_init_database(rtxn.txn, name, None, false) {
@@ -500,11 +500,11 @@ impl Env {
     /// LMDB have an important restriction on the unnamed database when named ones are opened,
     /// the names of the named databases are stored as keys in the unnamed one and are immutable,
     /// these keys can only be read and not written.
-    pub fn create_database<KC, DC>(
+    pub fn create_database<'t, KC, DC>(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &'t mut RwTxn,
         name: Option<&str>,
-    ) -> Result<Database<KC, DC>>
+    ) -> Result<Database<'t, KC, DC>>
     where
         KC: 'static,
         DC: 'static,
@@ -527,11 +527,11 @@ impl Env {
     /// LMDB have an important restriction on the unnamed database when named ones are opened,
     /// the names of the named databases are stored as keys in the unnamed one and are immutable,
     /// these keys can only be read and not written.
-    pub fn create_poly_database(
+    pub fn create_poly_database<'t>(
         &self,
-        wtxn: &mut RwTxn,
+        wtxn: &'t mut RwTxn,
         name: Option<&str>,
-    ) -> Result<PolyDatabase> {
+    ) -> Result<PolyDatabase<'t>> {
         assert_eq_env_txn!(self, wtxn);
 
         match self.raw_init_database(wtxn.txn.txn, name, None, true) {