Add unregister method

Author: georgestagg

CLAUDE.md

@@ -209,6 +209,7 @@ let json = writer.render(&spec)?;
 
 - `execute_sql(sql)` - Run SQL, return DataFrame
 - `register(name, df)` - Register DataFrame as table
+- `unregister(name)` - Unregister a previously registered table
 - Implementation: `DuckDBReader`
 
 **Writer trait** (output format abstraction):
@@ -1000,6 +1001,7 @@ Optional methods for custom readers:
 
 - `supports_register() -> bool` - Return `True` if registration is supported
 - `register(name: str, df: polars.DataFrame) -> None` - Register a DataFrame as a table
+- `unregister(name: str) -> None` - Unregister a previously registered table
 
 Native readers (e.g., `DuckDBReader`) use an optimized fast path, while custom Python readers are automatically bridged via IPC serialization.
 

ggsql-python/README.md

@@ -126,6 +126,7 @@ reader = ggsql.DuckDBReader("duckdb:///path/to/file.db")  # File database
 **Methods:**
 
 - `register(name: str, df: polars.DataFrame)` - Register a DataFrame as a queryable table
+- `unregister(name: str)` - Unregister a previously registered table
 - `execute_sql(sql: str) -> polars.DataFrame` - Execute SQL and return results
 - `supports_register() -> bool` - Check if registration is supported
 
@@ -266,6 +267,7 @@ json_output = writer.render(spec)
 
 - `supports_register() -> bool` - Return `True` if your reader supports DataFrame registration
 - `register(name: str, df: polars.DataFrame) -> None` - Register a DataFrame as a queryable table
+- `unregister(name: str) -> None` - Unregister a previously registered table
 
 ```python
 class AdvancedReader:
@@ -283,6 +285,9 @@ class AdvancedReader:
 
     def register(self, name: str, df: pl.DataFrame) -> None:
         self.tables[name] = df
+
+    def unregister(self, name: str) -> None:
+        del self.tables[name]
 ```
 
 Native readers like `DuckDBReader` use an optimized fast path, while custom Python readers are automatically bridged via IPC serialization.

ggsql-python/src/lib.rs

@@ -159,6 +159,18 @@ impl Reader for PyReaderBridge {
             Ok(())
         })
     }
+
+    fn unregister(&mut self, name: &str) -> ggsql::Result<()> {
+        Python::attach(|py| {
+            self.obj
+                .bind(py)
+                .call_method1("unregister", (name,))
+                .map_err(|e| {
+                    GgsqlError::ReaderError(format!("Reader.unregister() failed: {}", e))
+                })?;
+            Ok(())
+        })
+    }
 }
 
 // ============================================================================
@@ -249,6 +261,23 @@ impl PyDuckDBReader {
             .map_err(|e| PyErr::new::<pyo3::exceptions::PyValueError, _>(e.to_string()))
     }
 
+    /// Unregister a previously registered table.
+    ///
+    /// Parameters
+    /// ----------
+    /// name : str
+    ///     The table name to unregister.
+    ///
+    /// Raises
+    /// ------
+    /// ValueError
+    ///     If the table wasn't registered via this reader or unregistration fails.
+    fn unregister(&mut self, name: &str) -> PyResult<()> {
+        self.inner
+            .unregister(name)
+            .map_err(|e| PyErr::new::<pyo3::exceptions::PyValueError, _>(e.to_string()))
+    }
+
     /// Execute a SQL query and return the result as a DataFrame.
     ///
     /// Parameters

src/doc/API.md

@@ -377,6 +377,9 @@ pub trait Reader {
     /// Register a DataFrame as a queryable table
     fn register(&mut self, name: &str, df: DataFrame) -> Result<()>;
 
+    /// Unregister a previously registered table
+    fn unregister(&mut self, name: &str) -> Result<()>;
+
     /// Check if this reader supports DataFrame registration
     fn supports_register(&self) -> bool;
 }
@@ -423,6 +426,13 @@ class DuckDBReader:
             df: Polars DataFrame or narwhals-compatible DataFrame
         """
 
+    def unregister(self, name: str) -> None:
+        """Unregister a previously registered table.
+
+        Args:
+            name: Table name to unregister
+        """
+
     def execute_sql(self, sql: str) -> polars.DataFrame:
         """Execute SQL and return a Polars DataFrame."""
 

src/reader/duckdb.rs

@@ -10,6 +10,7 @@ use duckdb::vtab::arrow::{arrow_recordbatch_to_query_params, ArrowVTab};
 use duckdb::{params, Connection};
 use polars::io::SerWriter;
 use polars::prelude::*;
+use std::collections::HashSet;
 use std::io::Cursor;
 
 /// DuckDB database reader
@@ -32,6 +33,7 @@ use std::io::Cursor;
 /// ```
 pub struct DuckDBReader {
     conn: Connection,
+    registered_tables: HashSet<String>,
 }
 
 impl DuckDBReader {
@@ -75,7 +77,10 @@ impl DuckDBReader {
                 GgsqlError::ReaderError(format!("Failed to register arrow function: {}", e))
             })?;
 
-        Ok(Self { conn })
+        Ok(Self {
+            conn,
+            registered_tables: HashSet::new(),
+        })
     }
 
     /// Get a reference to the underlying DuckDB connection
@@ -523,6 +528,30 @@ impl Reader for DuckDBReader {
             GgsqlError::ReaderError(format!("Failed to register table '{}': {}", name, e))
         })?;
 
+        // Track the table so we can unregister it later
+        self.registered_tables.insert(name.to_string());
+
+        Ok(())
+    }
+
+    fn unregister(&mut self, name: &str) -> Result<()> {
+        // Only allow unregistering tables we created via register()
+        if !self.registered_tables.contains(name) {
+            return Err(GgsqlError::ReaderError(format!(
+                "Table '{}' was not registered via this reader",
+                name
+            )));
+        }
+
+        // Drop the temp table
+        let sql = format!("DROP TABLE IF EXISTS \"{}\"", name);
+        self.conn.execute(&sql, []).map_err(|e| {
+            GgsqlError::ReaderError(format!("Failed to unregister table '{}': {}", name, e))
+        })?;
+
+        // Remove from tracking
+        self.registered_tables.remove(name);
+
         Ok(())
     }
 
@@ -704,4 +733,54 @@ mod tests {
         assert_eq!(result.shape(), (0, 2));
         assert_eq!(result.get_column_names(), vec!["x", "y"]);
     }
+
+    #[test]
+    fn test_unregister() {
+        let mut reader = DuckDBReader::from_connection_string("duckdb://memory").unwrap();
+        let df = DataFrame::new(vec![Column::new("x".into(), vec![1i32, 2, 3])]).unwrap();
+
+        reader.register("test_data", df).unwrap();
+
+        // Should be queryable
+        let result = reader.execute_sql("SELECT * FROM test_data").unwrap();
+        assert_eq!(result.height(), 3);
+
+        // Unregister
+        reader.unregister("test_data").unwrap();
+
+        // Should no longer exist
+        let result = reader.execute_sql("SELECT * FROM test_data");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_unregister_not_registered() {
+        let mut reader = DuckDBReader::from_connection_string("duckdb://memory").unwrap();
+
+        // Create a table directly (not via register)
+        reader
+            .connection()
+            .execute("CREATE TABLE user_table (x INT)", params![])
+            .unwrap();
+
+        // Should fail - we didn't register this via register()
+        let result = reader.unregister("user_table");
+        assert!(result.is_err());
+        let err = result.unwrap_err().to_string();
+        assert!(err.contains("was not registered via this reader"));
+    }
+
+    #[test]
+    fn test_reregister_after_unregister() {
+        let mut reader = DuckDBReader::from_connection_string("duckdb://memory").unwrap();
+        let df = DataFrame::new(vec![Column::new("x".into(), vec![1i32, 2, 3])]).unwrap();
+
+        reader.register("data", df.clone()).unwrap();
+        reader.unregister("data").unwrap();
+
+        // Should be able to register again
+        reader.register("data", df).unwrap();
+        let result = reader.execute_sql("SELECT * FROM data").unwrap();
+        assert_eq!(result.height(), 3);
+    }
 }

src/reader/mod.rs

@@ -147,6 +147,26 @@ pub trait Reader {
         )))
     }
 
+    /// Unregister a previously registered table
+    ///
+    /// # Arguments
+    ///
+    /// * `name` - The table name to unregister
+    ///
+    /// # Returns
+    ///
+    /// `Ok(())` on success.
+    ///
+    /// # Default Implementation
+    ///
+    /// Returns an error by default. Override for readers that support registration.
+    fn unregister(&mut self, name: &str) -> Result<()> {
+        Err(GgsqlError::ReaderError(format!(
+            "This reader does not support unregistering table '{}'",
+            name
+        )))
+    }
+
     /// Check if this reader supports DataFrame registration
     ///
     /// # Returns