fix: name the declared table when its value will not import

A junk table value fell through to the pyarrow Dataset fallback, whose
error names neither the table nor the bundle. The declared name is
unique within the call, so wrapping the import error with it points at
one declaration — the same repair the rules got, adapted to a component
whose value has four legal shapes and so cannot be pre-checked in
Python.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: timsaucer

crates/core/src/context.rs

@@ -1785,7 +1785,13 @@ impl PySessionContext {
 
         let mut resolved = Vec::with_capacity(tables.len());
         for (name, obj) in tables {
-            let provider = PyTable::new(obj, Some(session.clone()))?.table;
+            // The name is the culprit's identity: it is unique within the call,
+            // so an import failure that carries it points at one declaration.
+            // The importer's own message names neither the table nor the
+            // bundle, because it never knew them.
+            let provider = PyTable::new(obj, Some(session.clone()))
+                .map_err(|err| exec_datafusion_err!("Resolving the declared table {name}: {err}"))?
+                .table;
             let reference = TableReference::from(name.as_str());
             let table_name = reference.table().to_owned();
             let schema = state.schema_for_ref(reference)?;

python/datafusion/context.py

@@ -2234,14 +2234,16 @@ def with_extensions(
                 a declared function or optimizer rule does not expose its
                 capsule getter and is not already a wrapper.
             ValueError: If two codecs claim the same id, if two extensions
-                declare a function of one kind under the same name, or if a
-                getter returns a capsule of the wrong kind. See
-                :py:meth:`with_logical_extension_codec` for how ids are
-                assigned.
+                declare a function, table, or table function of one kind under
+                the same name, or if a getter returns a capsule of the wrong
+                kind. See :py:meth:`with_logical_extension_codec` for how ids
+                are assigned.
             RuntimeError: If a getter is present but returns something that is
                 not a ``PyCapsule`` at all. The message comes from the importer
                 and does not name the bundle, because by then the declaration
                 has already been accepted as the right shape.
+            Exception: If a declared table cannot be resolved — the name is
+                taken, the schema unknown, or the value not a table.
 
         Examples:
             The returned handle is a different object sharing one session, and

python/tests/test_context.py

@@ -1753,6 +1753,24 @@ def test_with_extensions_rejects_a_table_in_an_unknown_schema(ctx):
         ctx.udf("double")
 
 
+def test_with_extensions_rejects_a_table_that_is_not_a_table_by_name(ctx):
+    """A declaration that is not a table at all is refused under its name.
+
+    A table value can be any of four shapes, so unlike a rule the junk is only
+    discovered by the importer, after the bundle can be named. The declared
+    name is unique within the call — that is what identifies the culprit.
+    """
+
+    with pytest.raises(Exception, match=r"declared table junk"):
+        ctx.with_extensions(
+            _FunctionExtension(udfs=(_doubler(),)),
+            _TableExtension(table_providers=(("junk", object()),)),
+        )
+
+    with pytest.raises(KeyError):
+        ctx.udf("double")
+
+
 def test_session_extension_components_rejects_a_single_optimizer_rule():
     """The same for rules, naming what that field holds."""
     with pytest.raises(