fix(types): handle Arrow-style type names from Parquet/managed tables; update docs

- types.py: add _ARROW_TYPE_MAP for Arrow-style names (Date32, Float64, Utf8, etc.)
  returned by the information_schema for Parquet/managed table columns
- tests: add parametrized test_dtype_from_hotdata_arrow_type_names covering all
  Arrow-style names and case-insensitivity
- README: update hotdata requirement to >=0.2.3; document Arrow-style type support
  in both the feature list and the Connect → Types section

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: eddietejeda

README.md

@@ -2,7 +2,7 @@
 
 Experimental [Ibis](https://ibis-project.org/) backend for [Hotdata](https://www.hotdata.dev/docs/api-reference): compile expressions with Ibis, run federated SQL over the Hotdata API. REST calls use the official **[hotdata](https://github.com/hotdata-dev/sdk-python)** Python SDK. Repo examples use **httpx** (listed under the **dev** dependency group).
 
-**Requirements:** Python 3.10+, **ibis-framework** 10.x, **hotdata** ≥0.2.
+**Requirements:** Python 3.10+, **ibis-framework** 10.x, **hotdata** ≥0.2.3.
 
 ## Install
 
@@ -16,7 +16,7 @@ uv pip install hotdata-ibis
 - **Ibis connection API** — connect with `ibis.hotdata.connect(...)` or `ibis.connect("hotdata://...")`.
 - **Hotdata catalog mapping** — expose Hotdata connections, schemas, and tables through Ibis catalogs, databases, and tables.
 - **SQL-backed expression execution** — compile Ibis expressions with the Postgres SQLGlot compiler and execute them through Hotdata query APIs.
-- **Typed table discovery** — load schema metadata from Hotdata information schema and map SQL types into Ibis types.
+- **Typed table discovery** — load schema metadata from Hotdata information schema and map SQL types into Ibis types. Both SQL-style names (`INTEGER`, `VARCHAR`) and Arrow-style names (`Float64`, `Utf8`) returned by Parquet/managed tables are handled.
 - **Arrow and pandas results** — materialize expressions as pandas DataFrames, PyArrow tables, or local Arrow record batches.
 - **Raw SQL escape hatch** — use `con.sql(..., dialect="postgres")` when Hotdata-specific federated SQL is clearer than modeled Ibis expressions.
 - **Managed database writes** — create managed connections with `create_database`, load local pandas or PyArrow data through `create_table`, and clean up with `drop_table` / `drop_database`.
@@ -56,7 +56,7 @@ con = ibis.connect(
 
 **Execution:** SQL is compiled with Ibis’s **Postgres** SQLGlot compiler. The client submits queries asynchronously with `POST /v1/query`, polls `GET /v1/query-runs/{id}`, then downloads ready results as Arrow IPC from `GET /v1/results/{id}`. Tuning: `poll_interval_s`, `poll_timeout_s` on `connect()`.
 
-**Types:** Typed tables come from Hotdata’s information schema. `con.sql(...)` types are inferred from a small preview query and Arrow schema; see [Hotdata SQL](https://www.hotdata.dev/docs/sql) for server behavior.
+**Types:** Typed tables come from Hotdata’s information schema. `con.sql(...)` types are inferred from a small preview query and Arrow schema. Both SQL-style names (`INTEGER`, `DOUBLE PRECISION`) and Arrow-style names (`Float64`, `Utf8`, `Date32`) returned by Parquet/managed tables are supported; see [Hotdata SQL](https://www.hotdata.dev/docs/sql) for server behavior.
 
 ## Ibis Support Overview
 

src/ibis_hotdata/types.py

@@ -5,11 +5,49 @@
 import ibis.expr.datatypes as dt
 from ibis.backends.sql.datatypes import PostgresType
 
+# Arrow-style type names returned by Hotdata's information_schema when tables are
+# loaded from Parquet/Arrow sources.  PostgresType.from_string() treats these as
+# USERDEFINED unknowns, so we resolve them explicitly before falling through.
+_ARROW_TYPE_MAP: dict[str, type[dt.DataType]] = {
+    # dates
+    "date32": dt.Date,
+    "date64": dt.Date,
+    # floats
+    "float16": dt.Float16,
+    "float32": dt.Float32,
+    "float64": dt.Float64,
+    # unsigned ints
+    "uint8": dt.UInt8,
+    "uint16": dt.UInt16,
+    "uint32": dt.UInt32,
+    "uint64": dt.UInt64,
+    # strings
+    "utf8": dt.String,
+    "largeutf8": dt.String,
+    # binary
+    "largebinary": dt.Binary,
+    # time
+    "time32": dt.Time,
+    "time64": dt.Time,
+}
+
 
 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."""
+    """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.
+    """
     if not sql_type:
         return dt.String(nullable=nullable)
+
+    # Arrow-style names (case-insensitive lookup).
+    arrow_cls = _ARROW_TYPE_MAP.get(sql_type.strip().lower())
+    if arrow_cls is not None:
+        return arrow_cls(nullable=nullable)
+
     try:
         return PostgresType.from_string(sql_type.strip(), nullable=nullable)
     except Exception:  # ibis/sqlglot raise a variety of parse errors; fall back to String

tests/test_hotdata_types.py

@@ -36,3 +36,32 @@ def test_dtype_from_hotdata_vendor_name_maps_or_string_fallback():
 def test_dtype_from_hotdata_malformed_fallback_string():
     out = dtype_from_hotdata_sql_type('"', nullable=False)
     assert isinstance(out, dt.String)
+
+
+@pytest.mark.parametrize(
+    ("sql_type", "nullable", "expected_cls"),
+    [
+        # Arrow-style names returned when tables are loaded from Parquet/Arrow sources
+        ("Date32", True, dt.Date),
+        ("Date64", False, dt.Date),
+        ("Float32", True, dt.Float32),
+        ("Float64", False, dt.Float64),
+        ("UInt8", True, dt.UInt8),
+        ("UInt16", True, dt.UInt16),
+        ("UInt32", True, dt.UInt32),
+        ("UInt64", True, dt.UInt64),
+        ("Utf8", True, dt.String),
+        ("LargeUtf8", False, dt.String),
+        ("LargeBinary", True, dt.Binary),
+        ("Time32", True, dt.Time),
+        ("Time64", False, dt.Time),
+        # Case-insensitive
+        ("date32", True, dt.Date),
+        ("FLOAT64", True, dt.Float64),
+        ("UTF8", True, dt.String),
+    ],
+)
+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)