P1 — Important (should fix)

1. ArrayParameter / MapParameter are silently bound as NULL — data corruption risk
   type_mapping.py:113-147, cross-ref parameters/native.py:470-535

The PR docstring says compound types "route through the kernel parser which currently rejects them." Reality: ArrayParameter.as_tspark_param() and MapParameter.as_tspark_param() build
TSparkParameter(type="ARRAY"/"MAP", ordinal=True) with tsp.value = None and the real payload on tsp.arguments (a list of TSparkParameterValueArg). bind_tspark_params only reads param.value and param.type;
arguments is never inspected. So:

• _tspark_param_value_str returns None
• kernel_stmt.bind_param(1, None, "ARRAY") is called
• Kernel binds a typed NULL — likely succeeds — and the user's list contents are silently discarded

cur.execute("SELECT array_contains(?, 1)", [ArrayParameter([1,2,3])]) returns NULL with no error from either side. This contradicts the documented behavior.

Fix: Detect compound types up front in bind_tspark_params and raise NotSupportedError:
if (param.type or "").split("(", 1)[0].upper() in {"ARRAY", "MAP", "STRUCT"}
or getattr(param, "arguments", None):
raise NotSupportedError(
f"Compound parameter types (got {param.type!r}) are not yet supported"
)
Add a unit test enforcing the guard.

2. test_bind_tspark_params_void_passes_through pins a shape the connector never produces
   tests/unit/test_kernel_type_mapping.py:141-149

The test builds _mk_param(type="VOID", value="None") → p.value = TSparkParameterValue(stringValue="None"). But VoidParameter._tspark_param_value() (parameters/native.py:337-339) returns Python None, so the
real wire shape is TSparkParameter(value=None, type="VOID", ordinal=True) and _tspark_param_value_str returns None (because param.value is None). The test asserts [(1, "None", "VOID")] — production call is
(1, None, "VOID"). The _tspark_param_value_str docstring at type_mapping.py:99-110 is misleading on the same point. Code is correct; the test just doesn't verify it.

Fix: Change _mk_param(type="VOID", value="None") to _mk_param(type="VOID", value=None) and assert [(1, None, "VOID")]. Correct the docstring.

3. Named-binding discriminator can mis-route when ordinal is None
   type_mapping.py:134

Thrift defaults ordinal=None, name=None. The check if getattr(param, "ordinal", None) is False and getattr(param, "name", None): only triggers when ordinal is exactly False. A TSparkParameter with
ordinal=None and a non-empty name (defensive caller, or a future code path that forgets to set ordinal) skips the guard and binds positionally with the name silently dropped. In-tree callers always set
ordinal=True/False, so unlikely today — but the guard is presented as a robustness net.

Fix:
name = getattr(param, "name", None)
if name and getattr(param, "ordinal", None) is not True:
raise NotSupportedError(...)

P2 — Minor

• Misleading lazy-import comment (client.py:243-248) — claims to avoid eager pyarrow load, but KernelResultSet (imported at top) already imports description_from_arrow_schema from type_mapping. Move to
  module top or fix the comment.
• NotSupportedError re-imported inside the loop body (type_mapping.py:135) — cached, but cleaner at module top.
• Partial-bind state on per-param failure (client.py:240-273) — relies on stmt.close() releasing partially-bound state. Worth a one-line confirming comment.
• SqlType.* refactor verified safe — SqlType.BOOLEAN == "boolean", SqlType.INT == "int" etc., all lowercase matching the prior literals. No cursor.description consumer break.
• type=None defaults to "STRING" (type_mapping.py:142) — connector's native classes always set type, so this only triggers for hand-rolled TSparkParameter. Consider raising instead of silently defaulting, to
  surface upstream bugs.

Thanks @gopalldb — addressed in f384f1a. Summary:

P1 #1 — compound types silently binding NULL (data loss)

You were right, this was a real bug. Added a guard in bind_tspark_params that rejects ARRAY / MAP / STRUCT (and any param with arguments set) up front with NotSupportedError. Detects both the SQL-type name (strips (...) and <...> suffixes so MAP(string,int) and STRUCT<a:int> are caught) and the presence of arguments so a hand-rolled compound TSparkParameter is also covered. 6 parametrized + 1 standalone unit tests enforce the guard.

P1 #2 — VOID test pinned the wrong shape

Confirmed: VoidParameter._tspark_param_value() returns Python None, so the production call is (1, None, "VOID"). Updated the test and corrected the misleading docstring on _tspark_param_value_str.

P1 #3 — named-binding discriminator

Tightened from ordinal is False and name → name and ordinal is not True, so a future caller that forgets to set ordinal=True with a name set still gets rejected instead of silently dropping the name. Added a defensive test for the ordinal=None case.

P2 cleanups

• Removed the misleading lazy-import comment in client.py. You're right that pyarrow is already loaded transitively via KernelResultSet (which imports description_from_arrow_schema from type_mapping at module top). Import moved to module top.
• NotSupportedError moved out of the loop body to module top in type_mapping.py.

P2 not changed (with rationale)

• type=None defaulting to "STRING": left as-is. The existing test test_bind_tspark_params_missing_type_defaults_to_string pins this defensive behavior, and the connector's native classes always set type so this only triggers for hand-rolled TSparkParameter. Happy to flip to raising if you'd prefer to surface upstream bugs more aggressively.
• Partial-bind state confirming comment: not added. stmt.close() in the finally block is the standard kernel lifecycle pattern used throughout this file; calling it out only here felt asymmetric.

Tests

• 35/35 in tests/unit/test_kernel_type_mapping.py pass (was 28; added 7 new cases).
• Full kernel unit suite: 114/114 (was 106).
• E2E suite unchanged from PR description.