Add static lifetime versions of range() and multimap table get()

These methods return reference counted iterators from read only
transactions

src/db.rs

@@ -6,8 +6,7 @@ use crate::tree_store::{
 };
 use crate::types::{RedbKey, RedbValue};
 use crate::{
-    CompactionError, DatabaseError, Durability, ReadOnlyTable, ReadableTable, SavepointError,
-    StorageError,
+    CompactionError, DatabaseError, Durability, ReadOnlyTable, SavepointError, StorageError,
 };
 use crate::{ReadTransaction, Result, WriteTransaction};
 use std::fmt::{Debug, Display, Formatter};

src/multimap_table.rs

@@ -1296,6 +1296,35 @@ impl<'txn, K: RedbKey + 'static, V: RedbKey + 'static> ReadOnlyMultimapTable<'tx
             _lifetime: Default::default(),
         })
     }
+
+    /// This method is like [`ReadableMultimapTable::get()`], but the iterator is reference counted and keeps the transaction
+    /// alive until it is dropped.
+    pub fn get<'a>(&self, key: impl Borrow<K::SelfType<'a>>) -> Result<MultimapValue<'static, V>> {
+        let iter = if let Some(collection) = self.tree.get(key.borrow())? {
+            DynamicCollection::iter(collection, self.transaction_guard.clone(), self.mem.clone())?
+        } else {
+            MultimapValue::new_subtree(
+                BtreeRangeIter::new::<RangeFull, &V::SelfType<'_>>(&(..), None, self.mem.clone())?,
+                self.transaction_guard.clone(),
+            )
+        };
+
+        Ok(iter)
+    }
+
+    /// This method is like [`ReadableMultimapTable::range()`], but the iterator is reference counted and keeps the transaction
+    /// alive until it is dropped.
+    pub fn range<'a, KR>(&self, range: impl RangeBounds<KR>) -> Result<MultimapRange<'static, K, V>>
+    where
+        KR: Borrow<K::SelfType<'a>>,
+    {
+        let inner = self.tree.range(&range)?;
+        Ok(MultimapRange::new(
+            inner,
+            self.transaction_guard.clone(),
+            self.mem.clone(),
+        ))
+    }
 }
 
 impl<'txn, K: RedbKey + 'static, V: RedbKey + 'static> ReadableMultimapTable<K, V>

src/table.rs

@@ -439,6 +439,17 @@ impl<'txn, K: RedbKey + 'static, V: RedbValue + 'static> ReadOnlyTable<'txn, K,
             _lifetime: Default::default(),
         })
     }
+
+    /// This method is like [`ReadableTable::range()`], but the iterator is reference counted and keeps the transaction
+    /// alive until it is dropped.
+    pub fn range<'a, KR>(&self, range: impl RangeBounds<KR>) -> Result<Range<'static, K, V>>
+    where
+        KR: Borrow<K::SelfType<'a>>,
+    {
+        self.tree
+            .range(&range)
+            .map(|x| Range::new(x, self.transaction_guard.clone()))
+    }
 }
 
 impl<'txn, K: RedbKey + 'static, V: RedbValue + 'static> ReadableTable<K, V>

tests/basic_tests.rs

@@ -1246,6 +1246,30 @@ fn range_lifetime() {
     assert!(iter.next().is_none());
 }
 
+#[test]
+fn range_arc() {
+    let tmpfile = create_tempfile();
+    let db = Database::create(tmpfile.path()).unwrap();
+
+    let definition: TableDefinition<&str, &str> = TableDefinition::new("x");
+
+    let write_txn = db.begin_write().unwrap();
+    {
+        let mut table = write_txn.open_table(definition).unwrap();
+        table.insert("hello", "world").unwrap();
+    }
+    write_txn.commit().unwrap();
+
+    let mut iter = {
+        let read_txn = db.begin_read().unwrap();
+        let table = read_txn.open_table(definition).unwrap();
+        let start = "hello".to_string();
+        table.range::<&str>(start.as_str()..).unwrap()
+    };
+    assert_eq!(iter.next().unwrap().unwrap().1.value(), "world");
+    assert!(iter.next().is_none());
+}
+
 #[test]
 fn drain_lifetime() {
     let tmpfile = create_tempfile();

tests/multimap_tests.rs

@@ -172,6 +172,64 @@ fn range_lifetime() {
     assert!(iter.next().is_none());
 }
 
+#[test]
+fn range_arc_lifetime() {
+    let tmpfile = create_tempfile();
+    let db = Database::create(tmpfile.path()).unwrap();
+
+    let definition: MultimapTableDefinition<&str, &str> = MultimapTableDefinition::new("x");
+
+    let write_txn = db.begin_write().unwrap();
+    {
+        let mut table = write_txn.open_multimap_table(definition).unwrap();
+        table.insert("hello", "world").unwrap();
+    }
+    write_txn.commit().unwrap();
+
+    let mut iter = {
+        let read_txn = db.begin_read().unwrap();
+        let table = read_txn.open_multimap_table(definition).unwrap();
+        let start = "hello".to_string();
+        table.range::<&str>(start.as_str()..).unwrap()
+    };
+    assert_eq!(
+        iter.next()
+            .unwrap()
+            .unwrap()
+            .1
+            .next()
+            .unwrap()
+            .unwrap()
+            .value(),
+        "world"
+    );
+    assert!(iter.next().is_none());
+}
+
+#[test]
+fn get_arc_lifetime() {
+    let tmpfile = create_tempfile();
+    let db = Database::create(tmpfile.path()).unwrap();
+
+    let definition: MultimapTableDefinition<&str, &str> = MultimapTableDefinition::new("x");
+
+    let write_txn = db.begin_write().unwrap();
+    {
+        let mut table = write_txn.open_multimap_table(definition).unwrap();
+        table.insert("hello", "world").unwrap();
+    }
+    write_txn.commit().unwrap();
+
+    let mut iter = {
+        let read_txn = db.begin_read().unwrap();
+        let table = read_txn.open_multimap_table(definition).unwrap();
+        let start = "hello".to_string();
+        table.get(start.as_str()).unwrap()
+    };
+    assert_eq!(iter.next().unwrap().unwrap().value(), "world");
+    assert!(iter.next().is_none());
+}
+
 #[test]
 fn delete() {
     let tmpfile = create_tempfile();