fix: recognize every spelling of a nullable array element

[shcheklein]

Stacked on #1975.

An array's element type was called nullable by testing the annotation against
(int, float, str, bool, bytes, datetime) — which only the plainest spelling
passes. Every one of these resolved to a non-nullable item and then refused
a None that Pydantic had happily accepted into the field:

list[Annotated[int, "meta"] | None]
list[Annotated[int | None, "meta"]]
list[Literal["a", "b"] | None]
list[Annotated[Literal["a", None], "meta"]]
list[str | Literal[None]]
list[Literal[None]]
list[SubclassedInt | None]          # class SubclassedInt(Int64)
tuple[str, Literal[None]]
tuple[int, int | None]

All ten already resolve to the right item type on main — Int64, String,
SubclassedInt — they simply were not marked nullable.

Ask Pydantic instead of taking the annotation apart

TypeAdapter(annotation).validate_python(None)

Pydantic validated the field in the first place, so this cannot disagree with
what a user can actually store, and every nesting is answered without a line of
introspection here: Annotated and Literal either way round, a None among a
Literal's values, a union arm, Literal[None] inside a union.

An earlier revision of this hand-rolled the peeling. It took four review rounds
to reach the cases above, and it was 35 lines against these 8.

Two things worth knowing about the call:

• It builds a schema (~34 µs), so it belongs where a column's type is
  resolved — once per column — and not anywhere a value passes through. There
  is a comment saying so.
• An SQLType subclass is not a type Pydantic can model at all
  (PydanticSchemaGenerationError), so that case falls back to looking for a
  None among the union arms.

Two smaller corrections

Only args[0] was asked, though a fixed tuple keeps every slot in the one
column — so tuple[int, int | None] missed its own nullable slot.

Nullability is now read from the resolved column type rather than the
annotation, by subclass, so a user's Int64 subclass is recognized as the scalar
it is.

Not covered

list[Annotated[str, "meta"] | Literal[None]] still raises
Cannot recognize type, as on main. That is item-type resolution rather than
nullability — the composition is recognized by neither the scalar table nor the
union handling. Recorded in
#1968.

Stack

1. fix: keep None in an array wherever it sits #1975 — None anywhere in an array
2. this PR — the spellings of a nullable element type
3. fix: store a list of models that admits a None #1977 — a list of models that admits a None

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.

📢 Thoughts on this report? Let us know!

[cloudflare-workers-and-pages]

Deploying datachain with    Cloudflare Pages

Latest commit:	0bfcc59
Status:	✅  Deploy successful!
Preview URL:	https://81aed3cb.datachain-2g6.pages.dev
Branch Preview URL:	https://fix-nullable-array-item-spel.datachain-2g6.pages.dev

View logs