[tae898]

What does this PR do?

I read the native wheel's columnar read path in #312: to_arrow, to_columns, to_dataframe and to_polars drain the result as one Python dict per row (_drain_dicts) and then build each column with per-value Python loops in src/arcadedb/_native/columns.py. This PR changes only that Python, so it needs no native image rebuild, and it is meant to return exactly the same values as before.

• columns.to_arrow tries pa.array(values) first. It keeps the old per-value rules (_kind and the typed pa.array calls with their text fallbacks) for a column that pyarrow cannot type, whatever the error (pa.array([2**63]) raises OverflowError, where the typed call raised ArrowInvalid), and for a column it types differently from the rules: a temporal type (the rules write timestamp[ms], inference gives timestamp[us] or date32) and an unsigned integer (an int above int64 is an error under the rules).
• columns._names tests each row's keys against the keys already seen with one set-like comparison, instead of one Python step per key of every row. The order is still the order of first sight. I did this once per call and not once per reply batch, because the rows reach columns.py as one list; a per-batch version would have to thread the names through the cursor.
• columns.to_columns calls _kind once per column, where it called it twice.
• NativeResultSet._fill can hand a reply's rows straight to a list, and _drain_dicts uses that, so the drain no longer builds a tuple per row and takes it apart with a generator. Rows already in the buffer (the first reply, or rows a caller has not taken) still come out of it.

I did not do the float32-tail view in codec.loads_tagged. A vector in a row must stay a list of Python floats for the public API (to_list(), to_json_list(), == against a list, json.dumps), and a view would hand out arrays or a lazy object instead. It is a change to the columnar path only, which belongs with the native columnar read frames in #312.

The test is tests/test_native_columns_reference.py (collected on the native wheel only). It keeps the old _kind, _names, to_columns and to_arrow as a private reference and compares the new code with it on 46 single-column cases (ints, floats, bools, strings, all-null, datetimes, dates, Decimals up to 80 digits, vectors, ragged lists, dicts, bytes, ints above int64 and beyond 2^53 next to floats), on a table of all of them, on null-heavy ragged tables of 1000 rows, on chosen column lists and on empty input. It compares schema, values, column order and, where the old code raised, the exception class. A second group compares _drain_dicts with row-by-row iteration on 5000 rows (more than the first reply and two further replies), with 1 to 4999 rows taken before the drain.

Related issues

Refs #312. This is the first, bindings-only part; the native columnar read frames are not here.

Performance changes

No speed or memory figure is claimed. The measurement is the profile study (bindings-readpath-profile) and the timed A/B (ab3), both queued; the numbers will go on #312.

Docs

None needed: no output and no API changed.

Checklist

• A regression test fails on the old code and passes on the new: the new code is checked against the old rules, not a changed behaviour; the tests that count _kind calls and the _inferred cases fail on the old code
• The test suite that the change can affect passes (CI is the first run)
• uvx pre-commit run --files <changed files> passes

🤖 Generated with Claude Code