feat: update documentation and examples to use TableProvider instead of Table

Author: kosiew

docs/source/user-guide/data-sources.rst

@@ -152,11 +152,11 @@ as Delta Lake. This will require a recent version of
 .. code-block:: python
 
     from deltalake import DeltaTable
-    from datafusion.catalog import Table
+    from datafusion import TableProvider
 
     delta_table = DeltaTable("path_to_table")
-    table = Table.from_capsule(delta_table)
-    ctx.register_table("my_delta_table", table)
+    provider = TableProvider.from_capsule(delta_table)
+    ctx.register_table("my_delta_table", provider)
     df = ctx.table("my_delta_table")
     df.show()
 

docs/source/user-guide/io/table_provider.rst

@@ -48,28 +48,28 @@ A complete example can be found in the `examples folder <https://github.com/apac
     }
 
 Once you have this library available, you can construct a
-:py:class:`~datafusion.catalog.Table` in Python and register it with the
-``SessionContext``.  Tables can be created either from the PyCapsule exposed by
+:py:class:`~datafusion.TableProvider` in Python and register it with the
+``SessionContext``.  Table providers can be created either from the PyCapsule exposed by
 your Rust provider or from an existing :py:class:`~datafusion.dataframe.DataFrame`
-view created via ``df.into_view()`` (or the alias ``Table.from_dataframe(df)``).
+using ``TableProvider.from_view()``.
 
 .. code-block:: python
 
-    from datafusion.catalog import Table
+    from datafusion import SessionContext, TableProvider
 
     ctx = SessionContext()
     provider = MyTableProvider()
 
-    table_from_capsule = Table.from_capsule(provider)
+    capsule_provider = TableProvider.from_capsule(provider)
 
     df = ctx.from_pydict({"a": [1]})
-    provider_from_view = df.into_view()
+    view_provider = TableProvider.from_view(df)
 
-    ctx.register_table("capsule_table", table_from_capsule)
-    ctx.register_table("view_table", provider_from_view)
+    ctx.register_table("capsule_table", capsule_provider)
+    ctx.register_table("view_table", view_provider)
 
     ctx.table("capsule_table").show()
     ctx.table("view_table").show()
 
-``Table.from_dataframe(df)`` is available as an alias for ``df.into_view()``,
-but the latter is the preferred API.
+Both ``TableProvider.from_capsule()`` and ``TableProvider.from_view()`` create
+table providers that can be registered with the SessionContext using ``register_table()``.

src/dataframe.rs

@@ -405,7 +405,7 @@ impl PyDataFrame {
     /// where objects are shared
     /// https://github.com/apache/datafusion-python/pull/1016#discussion_r1983239116
     /// - we have not decided on the table_provider approach yet
-        #[allow(clippy::wrong_self_convention)]
+    #[allow(clippy::wrong_self_convention)]
     pub fn into_view(&self) -> PyDataFusionResult<PyTableProvider> {
         // Call the underlying Rust DataFrame::into_view method.
         // Note that the Rust method consumes self; here we clone the inner Arc<DataFrame>

src/table.rs

@@ -114,6 +114,7 @@ impl PyTableProvider {
     }
 }
 
+#[deprecated(note = "Use PyTableProvider methods (as_arc, into_inner) directly instead")]
 pub(crate) fn pyany_to_table_provider(
     table_provider: &Bound<'_, PyAny>,
 ) -> PyResult<Arc<dyn TableProvider + Send>> {
@@ -130,7 +131,7 @@ pub(crate) fn pyany_to_table_provider(
     } else if let Ok(py_table) = table_provider.extract::<PyTable>() {
         Ok(py_table.table())
     } else if let Ok(py_provider) = table_provider.extract::<PyTableProvider>() {
-        Ok(py_provider.as_table().table())
+        Ok(py_provider.as_arc())
     } else if let Ok(inner) = table_provider.getattr("table") {
         pyany_to_table_provider(&inner)
     } else {