Add int64 fallback for dictionary index width

Cap coordinate dictionary indices at the correct width for any cardinality:
the selection now tiers int8 → int16 → int32 → int64 at exact `MAX + 1`
boundaries (indices run 0..n-1, so a signed max M holds n = M+1). The int64
fallback keeps astronomically large coordinate axes representable instead of
silently overflowing a 32-bit index.

Follows the adaptive-key-width note in jayendra13's zarr-datafusion.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019VuSeCio99NcME5eubcN3N

Author: claude

tests/test_dict_coords.py

@@ -11,10 +11,32 @@
 
 import numpy as np
 import pyarrow as pa
+import pytest
 import xarray as xr
 
 from xarray_sql import XarrayContext
-from xarray_sql.df import _parse_schema, block_slices, iter_record_batches
+from xarray_sql.df import (
+    _coord_index_type,
+    _parse_schema,
+    block_slices,
+    iter_record_batches,
+)
+
+
+@pytest.mark.parametrize(
+    "n_values, expected",
+    [
+        (1, pa.int8()),
+        (128, pa.int8()),  # int8 holds indices 0..127
+        (129, pa.int16()),
+        (32768, pa.int16()),  # int16 holds indices 0..32767
+        (32769, pa.int32()),
+        (2**31, pa.int32()),  # int32 holds indices 0..2**31-1
+        (2**31 + 1, pa.int64()),  # fallback keeps huge axes representable
+    ],
+)
+def test_coord_index_type_boundaries(n_values, expected):
+    assert _coord_index_type(n_values) == expected
 
 
 def _grid() -> xr.Dataset:

xarray_sql/df.py

@@ -403,12 +403,19 @@ def _coord_index_type(n_values: int) -> pa.DataType:
     partition's cardinality). Narrower indices mean fewer bytes moved and cheaper
     group/join hashing: a 721-point latitude or 1440-point longitude fits int16,
     while a multi-million-step time axis needs int32.
+
+    Indices run ``0 .. n_values - 1``, so a signed type with maximum ``M`` holds
+    a cardinality of ``M + 1``. The ``int64`` fallback keeps astronomically large
+    coordinate axes representable rather than silently overflowing a 32-bit index
+    (cf. the adaptive-key-width note in jayendra13's zarr-datafusion).
     """
-    if n_values <= np.iinfo(np.int8).max:
+    if n_values <= np.iinfo(np.int8).max + 1:
         return pa.int8()
-    if n_values <= np.iinfo(np.int16).max:
+    if n_values <= np.iinfo(np.int16).max + 1:
         return pa.int16()
-    return pa.int32()
+    if n_values <= np.iinfo(np.int32).max + 1:
+        return pa.int32()
+    return pa.int64()
 
 
 def _as_dictionary_field(field: pa.Field, n_values: int) -> pa.Field: