feat: complete Arrow type mapping for parametric and missing types

Add support for all common Arrow type strings returned by Hotdata's
information_schema when tables are loaded from Parquet/Arrow sources.

Simple additions to _ARROW_TYPE_MAP:
- int8 → dt.Int8 (Postgres parser wrongly returns Int64 for "int8")
- halffloat → dt.Float16 (PyArrow's str() name for float16
- large_string → dt.String (PyArrow large-offset string variant)

New _parse_parametric_arrow_type() for types with embedded parameters:
- timestamp[us] / timestamp[us, tz=UTC] → dt.Timestamp(timezone=...)
- duration[ms] → dt.Interval(unit='ms')
- decimal128(10, 3) / decimal(5, 2) → dt.Decimal(precision, scale)
- list<item: T> / large_list<item: T> → dt.Array(T) (recursive)

Adds 27 new test cases covering all new patterns including timezone
variants, all 4 time units, case-insensitivity, and recursive list
element type resolution.
EOF
)

Author: eddietejeda

src/ibis_hotdata/types.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import re
+
 import ibis.expr.datatypes as dt
 from ibis.backends.sql.datatypes import PostgresType
 
@@ -12,43 +14,99 @@
     # dates
     "date32": dt.Date,
     "date64": dt.Date,
-    # floats
+    # floats — "halffloat" is PyArrow's str() name for float16
     "float16": dt.Float16,
     "float32": dt.Float32,
     "float64": dt.Float64,
+    "halffloat": dt.Float16,
+    # signed ints — must override Postgres parser: Postgres "int8" means 8-byte (64-bit),
+    # but Arrow "int8" means 8-bit.  int16/32/64 parse correctly via Postgres.
+    "int8": dt.Int8,
     # unsigned ints
     "uint8": dt.UInt8,
     "uint16": dt.UInt16,
     "uint32": dt.UInt32,
     "uint64": dt.UInt64,
-    # strings
+    # strings — "large_string" / "largeutf8" are PyArrow large-offset variants
     "utf8": dt.String,
     "largeutf8": dt.String,
+    "large_string": dt.String,
     # binary
     "largebinary": dt.Binary,
     # time
     "time32": dt.Time,
     "time64": dt.Time,
 }
 
+# Regex patterns for Arrow parametric types whose string representation includes
+# embedded parameters (unit, timezone, precision, value type, …).
+_TIMESTAMP_RE = re.compile(r"^timestamp\[(\w+)(?:,\s*tz=(.+))?\]$", re.IGNORECASE)
+_DURATION_RE = re.compile(r"^duration\[(\w+)\]$", re.IGNORECASE)
+_DECIMAL_RE = re.compile(r"^decimal128?\((\d+),\s*(\d+)\)$", re.IGNORECASE)
+_LIST_RE = re.compile(r"^(?:large_)?list<item:\s*(.+)>$", re.IGNORECASE)
+
+# Map Arrow time-unit strings to Ibis IntervalUnit strings.
+_ARROW_UNIT_TO_IBIS: dict[str, str] = {
+    "s": "s",
+    "ms": "ms",
+    "us": "us",
+    "ns": "ns",
+}
+
+
+def _parse_parametric_arrow_type(raw: str, *, nullable: bool) -> dt.DataType | None:
+    """Try to parse an Arrow parametric type string into an Ibis DataType.
+
+    Returns ``None`` if ``raw`` does not match any known parametric pattern,
+    allowing the caller to fall through to the Postgres dialect parser.
+    """
+    m = _TIMESTAMP_RE.match(raw)
+    if m:
+        tz: str | None = m.group(2).strip() if m.group(2) else None
+        return dt.Timestamp(timezone=tz, nullable=nullable)
+
+    m = _DURATION_RE.match(raw)
+    if m:
+        unit = _ARROW_UNIT_TO_IBIS.get(m.group(1).lower(), "s")
+        return dt.Interval(unit=unit, nullable=nullable)
+
+    m = _DECIMAL_RE.match(raw)
+    if m:
+        return dt.Decimal(precision=int(m.group(1)), scale=int(m.group(2)), nullable=nullable)
+
+    m = _LIST_RE.match(raw)
+    if m:
+        value_type = dtype_from_hotdata_sql_type(m.group(1).strip(), nullable=True)
+        return dt.Array(value_type=value_type, nullable=nullable)
+
+    return None
+
 
 def dtype_from_hotdata_sql_type(sql_type: str | None, *, nullable: bool) -> dt.DataType:
     """Best-effort mapping from Hotdata `/information_schema` column `data_type` strings.
 
     Hotdata may return either SQL-style names (``INTEGER``, ``VARCHAR``, ``DOUBLE
     PRECISION``, …) or Arrow-style names (``Date32``, ``Float64``, ``Utf8``, …).
     SQL-style names are delegated to the Postgres dialect parser; Arrow-style names
-    are resolved via an explicit lookup table before falling back to the parser.
+    are resolved via an explicit lookup table or parametric pattern before falling
+    back to the parser.
     """
     if not sql_type:
         return dt.String(nullable=nullable)
 
+    raw = sql_type.strip()
+
     # Arrow-style names (case-insensitive lookup).
-    arrow_cls = _ARROW_TYPE_MAP.get(sql_type.strip().lower())
+    arrow_cls = _ARROW_TYPE_MAP.get(raw.lower())
     if arrow_cls is not None:
         return arrow_cls(nullable=nullable)
 
+    # Arrow parametric types (timestamp[us], duration[ms], decimal128(p,s), list<…>).
+    parametric = _parse_parametric_arrow_type(raw, nullable=nullable)
+    if parametric is not None:
+        return parametric
+
     try:
-        return PostgresType.from_string(sql_type.strip(), nullable=nullable)
+        return PostgresType.from_string(raw, nullable=nullable)
     except Exception:  # ibis/sqlglot raise a variety of parse errors; fall back to String
         return dt.String(nullable=nullable)

tests/test_hotdata_types.py

@@ -55,6 +55,15 @@ def test_dtype_from_hotdata_malformed_fallback_string():
         ("LargeBinary", True, dt.Binary),
         ("Time32", True, dt.Time),
         ("Time64", False, dt.Time),
+        # Previously missing: signed int8 (Postgres "int8" means int64, not int8)
+        ("int8", True, dt.Int8),
+        ("Int8", False, dt.Int8),
+        # Previously missing: halffloat (PyArrow's str() name for float16)
+        ("halffloat", True, dt.Float16),
+        ("HALFFLOAT", False, dt.Float16),
+        # Previously missing: large_string (PyArrow large-offset string variant)
+        ("large_string", True, dt.String),
+        ("Large_String", False, dt.String),
         # Case-insensitive
         ("date32", True, dt.Date),
         ("FLOAT64", True, dt.Float64),
@@ -65,3 +74,73 @@ def test_dtype_from_hotdata_arrow_type_names(sql_type, nullable, expected_cls):
     out = dtype_from_hotdata_sql_type(sql_type, nullable=nullable)
     assert out.nullable is nullable
     assert isinstance(out, expected_cls)
+
+
+@pytest.mark.parametrize(
+    ("sql_type", "expected_tz"),
+    [
+        ("timestamp[s]", None),
+        ("timestamp[ms]", None),
+        ("timestamp[us]", None),
+        ("timestamp[ns]", None),
+        ("timestamp[us, tz=UTC]", "UTC"),
+        ("timestamp[us, tz=America/New_York]", "America/New_York"),
+        ("TIMESTAMP[US]", None),
+    ],
+)
+def test_dtype_from_hotdata_arrow_timestamp(sql_type, expected_tz):
+    out = dtype_from_hotdata_sql_type(sql_type, nullable=True)
+    assert isinstance(out, dt.Timestamp)
+    assert out.timezone == expected_tz
+    assert out.nullable is True
+
+
+@pytest.mark.parametrize(
+    ("sql_type", "expected_unit"),
+    [
+        ("duration[s]", "s"),
+        ("duration[ms]", "ms"),
+        ("duration[us]", "us"),
+        ("duration[ns]", "ns"),
+        ("DURATION[MS]", "ms"),
+    ],
+)
+def test_dtype_from_hotdata_arrow_duration(sql_type, expected_unit):
+    out = dtype_from_hotdata_sql_type(sql_type, nullable=False)
+    assert isinstance(out, dt.Interval)
+    assert out.unit.value == expected_unit
+    assert out.nullable is False
+
+
+@pytest.mark.parametrize(
+    ("sql_type", "expected_precision", "expected_scale"),
+    [
+        ("decimal128(10, 3)", 10, 3),
+        ("decimal128(38, 0)", 38, 0),
+        ("decimal(5, 2)", 5, 2),
+        ("DECIMAL128(18, 6)", 18, 6),
+    ],
+)
+def test_dtype_from_hotdata_arrow_decimal(sql_type, expected_precision, expected_scale):
+    out = dtype_from_hotdata_sql_type(sql_type, nullable=True)
+    assert isinstance(out, dt.Decimal)
+    assert out.precision == expected_precision
+    assert out.scale == expected_scale
+    assert out.nullable is True
+
+
+@pytest.mark.parametrize(
+    ("sql_type", "expected_value_cls"),
+    [
+        ("list<item: int32>", dt.Int32),
+        ("list<item: utf8>", dt.String),
+        ("list<item: float64>", dt.Float64),
+        ("large_list<item: int64>", dt.Int64),
+        ("LIST<ITEM: UINT8>", dt.UInt8),
+    ],
+)
+def test_dtype_from_hotdata_arrow_list(sql_type, expected_value_cls):
+    out = dtype_from_hotdata_sql_type(sql_type, nullable=True)
+    assert isinstance(out, dt.Array)
+    assert isinstance(out.value_type, expected_value_cls)
+    assert out.nullable is True