Add rename_table() and rename_multimap_table()

Author: cberner

src/error.rs

@@ -93,6 +93,8 @@ pub enum TableError {
     },
     /// Table name does not match any table in database
     TableDoesNotExist(String),
+    /// Table name already exists in the database
+    TableExists(String),
     // Tables cannot be opened for writing multiple times, since they could retrieve immutable &
     // mutable references to the same dirty pages, or multiple mutable references via insert_reserve()
     TableAlreadyOpen(String, &'static panic::Location<'static>),
@@ -108,6 +110,7 @@ impl TableError {
             | TableError::TableIsNotMultimap(_)
             | TableError::TypeDefinitionChanged { .. }
             | TableError::TableDoesNotExist(_)
+            | TableError::TableExists(_)
             | TableError::TableAlreadyOpen(_, _) => {
                 StorageError::Corrupted(format!("{msg}: {self}"))
             }
@@ -134,6 +137,7 @@ impl From<TableError> for Error {
             TableError::TableIsMultimap(table) => Error::TableIsMultimap(table),
             TableError::TableIsNotMultimap(table) => Error::TableIsNotMultimap(table),
             TableError::TableDoesNotExist(table) => Error::TableDoesNotExist(table),
+            TableError::TableExists(table) => Error::TableExists(table),
             TableError::TableAlreadyOpen(name, location) => Error::TableAlreadyOpen(name, location),
             TableError::Storage(storage) => storage.into(),
         }
@@ -179,6 +183,9 @@ impl Display for TableError {
             TableError::TableDoesNotExist(table) => {
                 write!(f, "Table '{table}' does not exist")
             }
+            TableError::TableExists(table) => {
+                write!(f, "Table '{table}' already exists")
+            }
             TableError::TableAlreadyOpen(name, location) => {
                 write!(f, "Table '{name}' already opened at: {location}")
             }
@@ -476,6 +483,8 @@ pub enum Error {
     },
     /// Table name does not match any table in database
     TableDoesNotExist(String),
+    /// Table name already exists in the database
+    TableExists(String),
     // Tables cannot be opened for writing multiple times, since they could retrieve immutable &
     // mutable references to the same dirty pages, or multiple mutable references via insert_reserve()
     TableAlreadyOpen(String, &'static panic::Location<'static>),
@@ -545,6 +554,9 @@ impl Display for Error {
             Error::TableDoesNotExist(table) => {
                 write!(f, "Table '{table}' does not exist")
             }
+            Error::TableExists(table) => {
+                write!(f, "Table '{table}' already exists")
+            }
             Error::TableAlreadyOpen(name, location) => {
                 write!(f, "Table '{name}' already opened at: {location}")
             }

src/transactions.rs

@@ -421,6 +421,46 @@ impl<'db> TableNamespace<'db> {
         ))
     }
 
+    #[track_caller]
+    fn inner_rename(
+        &mut self,
+        name: &str,
+        new_name: &str,
+        table_type: TableType,
+    ) -> Result<(), TableError> {
+        if let Some(location) = self.open_tables.get(name) {
+            return Err(TableError::TableAlreadyOpen(name.to_string(), location));
+        }
+
+        self.table_tree.rename_table(name, new_name, table_type)
+    }
+
+    #[track_caller]
+    fn rename_table(
+        &mut self,
+        transaction: &WriteTransaction,
+        name: &str,
+        new_name: &str,
+    ) -> Result<(), TableError> {
+        #[cfg(feature = "logging")]
+        debug!("Renaming table: {} to {}", name, new_name);
+        transaction.dirty.store(true, Ordering::Release);
+        self.inner_rename(name, new_name, TableType::Normal)
+    }
+
+    #[track_caller]
+    fn rename_multimap_table(
+        &mut self,
+        transaction: &WriteTransaction,
+        name: &str,
+        new_name: &str,
+    ) -> Result<(), TableError> {
+        #[cfg(feature = "logging")]
+        debug!("Renaming multimap table: {} to {}", name, new_name);
+        transaction.dirty.store(true, Ordering::Release);
+        self.inner_rename(name, new_name, TableType::Multimap)
+    }
+
     #[track_caller]
     fn inner_delete(&mut self, name: &str, table_type: TableType) -> Result<bool, TableError> {
         if let Some(location) = self.open_tables.get(name) {
@@ -1140,6 +1180,36 @@ impl WriteTransaction {
         self.tables.lock().unwrap().close_table(name, table, length);
     }
 
+    /// Rename the given table
+    pub fn rename_table(
+        &self,
+        definition: impl TableHandle,
+        new_name: impl TableHandle,
+    ) -> Result<(), TableError> {
+        let name = definition.name().to_string();
+        // Drop the definition so that callers can pass in a `Table` to rename, without getting a TableAlreadyOpen error
+        drop(definition);
+        self.tables
+            .lock()
+            .unwrap()
+            .rename_table(self, &name, new_name.name())
+    }
+
+    /// Rename the given multimap table
+    pub fn rename_multimap_table(
+        &self,
+        definition: impl MultimapTableHandle,
+        new_name: impl MultimapTableHandle,
+    ) -> Result<(), TableError> {
+        let name = definition.name().to_string();
+        // Drop the definition so that callers can pass in a `MultimapTable` to rename, without getting a TableAlreadyOpen error
+        drop(definition);
+        self.tables
+            .lock()
+            .unwrap()
+            .rename_multimap_table(self, &name, new_name.name())
+    }
+
     /// Delete the given table
     ///
     /// Returns a bool indicating whether the table existed

src/tree_store/table_tree.rs

@@ -557,6 +557,29 @@ impl<'txn> TableTreeMut<'txn> {
         result
     }
 
+    pub(crate) fn rename_table(
+        &mut self,
+        name: &str,
+        new_name: &str,
+        table_type: TableType,
+    ) -> Result<(), TableError> {
+        if let Some(definition) = self.get_table_untyped(name, table_type)? {
+            if self.get_table_untyped(new_name, table_type)?.is_some() {
+                return Err(TableError::TableExists(new_name.to_string()));
+            }
+            if let Some(update) = self.pending_table_updates.remove(name) {
+                self.pending_table_updates
+                    .insert(new_name.to_string(), update);
+            }
+            assert!(self.tree.remove(&name)?.is_some());
+            assert!(self.tree.insert(&new_name, &definition)?.is_none());
+        } else {
+            return Err(TableError::TableDoesNotExist(name.to_string()));
+        }
+
+        Ok(())
+    }
+
     pub(crate) fn delete_table(
         &mut self,
         name: &str,

tests/basic_tests.rs

@@ -944,6 +944,65 @@ fn delete_table() {
     write_txn.commit().unwrap();
 }
 
+#[test]
+fn rename_table() {
+    let table_def: TableDefinition<&str, &str> = TableDefinition::new("x");
+    let table_def2: TableDefinition<&str, &str> = TableDefinition::new("x2");
+    let multitable_def: MultimapTableDefinition<&str, &str> = MultimapTableDefinition::new("x");
+    let multitable_def2: MultimapTableDefinition<&str, &str> = MultimapTableDefinition::new("x2");
+
+    let tmpfile = create_tempfile();
+    let db = Database::create(tmpfile.path()).unwrap();
+    let write_txn = db.begin_write().unwrap();
+    {
+        let mut table = write_txn.open_table(table_def).unwrap();
+        table.insert("hi", "hi").unwrap();
+        write_txn.rename_table(table, table_def2).unwrap();
+        assert!(matches!(
+            write_txn.rename_table(table_def, table_def2).unwrap_err(),
+            TableError::TableDoesNotExist(_)
+        ));
+
+        let table = write_txn.open_table(table_def).unwrap();
+        assert!(matches!(
+            write_txn.rename_table(table, table_def2).unwrap_err(),
+            TableError::TableExists(_)
+        ));
+
+        assert!(matches!(
+            write_txn
+                .rename_multimap_table(multitable_def, multitable_def2)
+                .unwrap_err(),
+            TableError::TableIsNotMultimap(_)
+        ));
+    }
+    write_txn.commit().unwrap();
+
+    let write_txn = db.begin_write().unwrap();
+    {
+        let table = write_txn.open_table(table_def).unwrap();
+        assert!(table.is_empty().unwrap());
+        let table2 = write_txn.open_table(table_def2).unwrap();
+        assert_eq!(table2.get("hi").unwrap().unwrap().value(), "hi");
+    }
+}
+
+#[test]
+fn rename_open_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!(matches!(
+            write_txn.rename_table(STR_TABLE, STR_TABLE).unwrap_err(),
+            TableError::TableAlreadyOpen(_, _)
+        ));
+        drop(table);
+    }
+    write_txn.commit().unwrap();
+}
+
 #[test]
 fn no_dirty_reads() {
     let tmpfile = create_tempfile();