Implement TableHandle for Table

src/multimap_table.rs

@@ -7,7 +7,7 @@ use crate::tree_store::{
     RawBtree, RawLeafBuilder, TransactionalMemory, UntypedBtreeMut, BRANCH, LEAF, MAX_VALUE_LENGTH,
 };
 use crate::types::{RedbKey, RedbValue, TypeName};
-use crate::{AccessGuard, Result, StorageError, WriteTransaction};
+use crate::{AccessGuard, MultimapTableHandle, Result, StorageError, WriteTransaction};
 use std::borrow::Borrow;
 use std::cmp::max;
 use std::convert::TryInto;
@@ -720,6 +720,14 @@ pub struct MultimapTable<'db, 'txn, K: RedbKey + 'static, V: RedbKey + 'static>
     _value_type: PhantomData<V>,
 }
 
+impl<K: RedbKey + 'static, V: RedbKey + 'static> MultimapTableHandle
+    for MultimapTable<'_, '_, K, V>
+{
+    fn name(&self) -> &str {
+        &self.name
+    }
+}
+
 impl<'db, 'txn, K: RedbKey + 'static, V: RedbKey + 'static> MultimapTable<'db, 'txn, K, V> {
     pub(crate) fn new(
         name: &str,
@@ -1120,7 +1128,7 @@ impl<'db, 'txn, K: RedbKey + 'static, V: RedbKey + 'static> ReadableMultimapTabl
     }
 }
 
-impl<K: RedbKey, V: RedbKey> Sealed for MultimapTable<'_, '_, K, V> {}
+impl<K: RedbKey + 'static, V: RedbKey + 'static> Sealed for MultimapTable<'_, '_, K, V> {}
 
 impl<'db, 'txn, K: RedbKey + 'static, V: RedbKey + 'static> Drop
     for MultimapTable<'db, 'txn, K, V>

src/table.rs

@@ -4,8 +4,8 @@ use crate::tree_store::{
     PageHint, PageNumber, TransactionalMemory, MAX_VALUE_LENGTH,
 };
 use crate::types::{RedbKey, RedbValue, RedbValueMutInPlace};
-use crate::Result;
 use crate::{AccessGuard, StorageError, WriteTransaction};
+use crate::{Result, TableHandle};
 use std::borrow::Borrow;
 use std::fmt::{Debug, Formatter};
 use std::ops::RangeBounds;
@@ -62,6 +62,12 @@ pub struct Table<'db, 'txn, K: RedbKey + 'static, V: RedbValue + 'static> {
     tree: BtreeMut<'txn, K, V>,
 }
 
+impl<K: RedbKey + 'static, V: RedbValue + 'static> TableHandle for Table<'_, '_, K, V> {
+    fn name(&self) -> &str {
+        &self.name
+    }
+}
+
 impl<'db, 'txn, K: RedbKey + 'static, V: RedbValue + 'static> Table<'db, 'txn, K, V> {
     pub(crate) fn new(
         name: &str,

src/transactions.rs

@@ -774,10 +774,10 @@ impl<'db> WriteTransaction<'db> {
     ///
     /// Returns a bool indicating whether the table existed
     pub fn delete_table(&self, definition: impl TableHandle) -> Result<bool, TableError> {
-        self.tables
-            .lock()
-            .unwrap()
-            .delete_table(self, definition.name())
+        let name = definition.name().to_string();
+        // Drop the definition so that callers can pass in a `Table` or `MultimapTable` to delete, without getting a TableAlreadyOpen error
+        drop(definition);
+        self.tables.lock().unwrap().delete_table(self, &name)
     }
 
     /// Delete the given table
@@ -787,10 +787,13 @@ impl<'db> WriteTransaction<'db> {
         &self,
         definition: impl MultimapTableHandle,
     ) -> Result<bool, TableError> {
+        let name = definition.name().to_string();
+        // Drop the definition so that callers can pass in a `Table` or `MultimapTable` to delete, without getting a TableAlreadyOpen error
+        drop(definition);
         self.tables
             .lock()
             .unwrap()
-            .delete_multimap_table(self, definition.name())
+            .delete_multimap_table(self, &name)
     }
 
     /// List all the tables

tests/basic_tests.rs

@@ -828,6 +828,18 @@ fn delete_open_table() {
     write_txn.commit().unwrap();
 }
 
+#[test]
+fn delete_table() {
+    let tmpfile = create_tempfile();
+    let db = Database::create(tmpfile.path()).unwrap();
+    let write_txn = db.begin_write().unwrap();
+    {
+        let table = write_txn.open_table(STR_TABLE).unwrap();
+        assert!(write_txn.delete_table(table).unwrap());
+    }
+    write_txn.commit().unwrap();
+}
+
 #[test]
 fn no_dirty_reads() {
     let tmpfile = create_tempfile();