feat: add as_table method to PyTableProvider and update into_view to return PyTable

Author: kosiew

python/tests/test_view.py

@@ -1,8 +1,3 @@
-"""
-This script demonstrates how to register a filtered DataFrame as a table
-using DataFusion's `ctx.register_table` method and then query it.
-"""
-
 from datafusion import SessionContext, col, literal
 import pyarrow as pa
 import pytest
@@ -23,7 +18,8 @@ def test_register_filtered_dataframe():
     # Filter the DataFrame (for example, keep rows where a > 2)
     df_filtered = df.filter(col("a") > literal(2))
     view = df_filtered.into_view()
-
+    
+ 
     # Register the filtered DataFrame as a table called "view1"
     ctx.register_table("view1", view)
 
@@ -43,3 +39,5 @@ def test_register_filtered_dataframe():
 
     # Assert the results match the expected results
     assert result_dicts == expected_results
+    
+    assert view.kind == "view"

src/dataframe.rs

@@ -40,6 +40,7 @@ use pyo3::pybacked::PyBackedStr;
 use pyo3::types::{PyCapsule, PyTuple, PyTupleMethods};
 use tokio::task::JoinHandle;
 
+use crate::catalog::PyTable;
 use crate::errors::{py_datafusion_err, PyDataFusionError};
 use crate::expr::sort_expr::to_sort_expressions;
 use crate::physical_plan::PyExecutionPlan;
@@ -64,6 +65,15 @@ impl PyTableProvider {
     pub fn get_provider(&self) -> Arc<dyn TableProvider> {
         self.provider.clone()
     }
+
+    /// Convert this TableProvider into a concrete Table wrapper, if possible.
+    pub fn as_table(&self) -> PyDataFusionResult<PyTable> {
+        // Here, you’d write the logic to convert your inner Arc<dyn TableProvider>
+        // to a PyTable (which is a Python–exposed concrete table type).
+        let table: Arc<dyn TableProvider> = self.provider.clone();
+        // Convert the trait object into your PyTable wrapper (if you have one)
+        Ok(PyTable::new(table))
+    }
 }
 
 /// A PyDataFrame is a representation of a logical plan and an API to compose statements.
@@ -106,12 +116,14 @@ impl PyDataFrame {
     }
 
     /// Convert this DataFrame into a view (i.e. a TableProvider) that can be registered.
-    fn into_view(&self) -> PyDataFusionResult<PyTableProvider> {
+    fn into_view(&self) -> PyDataFusionResult<PyTable> {
         // Call the underlying Rust DataFrame::into_view method.
         // Note that the Rust method consumes self; here we clone the inner Arc<DataFrame>
         // so that we don’t invalidate this PyDataFrame.
         let table_provider = self.df.as_ref().clone().into_view();
-        Ok(PyTableProvider::new(table_provider))
+        let table_provider = PyTableProvider::new(table_provider);
+
+        Ok(table_provider.as_table()?)
     }
 
     fn __repr__(&self, py: Python) -> PyDataFusionResult<String> {