graphique 2.1__tar.gz → 2.2__tar.gz

{graphique-2.1 → graphique-2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphique
-Version: 2.1
+Version: 2.2
 Summary: GraphQL service for python dataframes and parquet datasets.
 Author: A. Coady
 License-Expression: Apache-2.0
@@ -8,33 +8,35 @@ Project-URL: Homepage, https://github.com/coady/graphique
 Project-URL: Documentation, https://coady.github.io/graphique
 Project-URL: Changelog, https://github.com/coady/graphique/blob/main/CHANGELOG.md
 Project-URL: Issues, https://github.com/coady/graphique/issues
-Keywords: graphql,ibis,dataframes,arrow,parquet
+Keywords: graphql,ibis,dataframes,arrow,parquet,duckdb
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Database :: Database Engines/Servers
 Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: pyarrow>=23
-Requires-Dist: strawberry-graphql[asgi,cli]>=0.288
+Requires-Dist: strawberry-graphql[asgi,cli]>=0.328.3
 Requires-Dist: ibis-framework>=10.7
-Requires-Dist: pyarrow-hotfix
 Requires-Dist: isodate>=0.7
+Requires-Dist: pyarrow-hotfix
+Requires-Dist: sqlglot<30.18
 Provides-Extra: server
 Requires-Dist: uvicorn[standard]; extra == "server"
 Requires-Dist: duckdb; extra == "server"
 Provides-Extra: cli
+Requires-Dist: duckdb; extra == "cli"
 Requires-Dist: tqdm; extra == "cli"
 Requires-Dist: typer; extra == "cli"
 Dynamic: license-file
@@ -49,14 +51,9 @@ Dynamic: license-file
 [![image](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![ty](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json)](https://github.com/astral-sh/ty)
 
-[GraphQL](https://graphql.org) service for [ibis](https://ibis-project.org) dataframes, [arrow](https://arrow.apache.org) tables, and [parquet](https://parquet.apache.org) datasets. The schema for a query API is derived automatically.
-
-## Version 2
-When this project started, there was no out-of-core execution engine with performance comparable to [PyArrow](https://arrow.apache.org/docs/python/index.html). So it effectively included one, based on datasets and [Acero](https://arrow.apache.org/docs/python/api/acero.html).
-
-Since then the ecosystem has grown considerably: [DuckDB](https://duckdb.org), [DataFusion](https://datafusion.apache.org), and [Ibis](https://ibis-project.org). As of version 2, graphique is based on `ibis`. It provides a common dataframe API for multiple backends, enabling graphique to also have a default but configurable backend.
+[GraphQL](https://graphql.org) service for [ibis](https://ibis-project.org) tables. Ibis supports [20+ backends](https://ibis-project.org/why#how-does-ibis-work) — DuckDB, PostgreSQL, Polars, BigQuery, etc. — so the same query API works across local files and remote databases. The schema is derived automatically.
 
-Being a major version upgrade, there are incompatible changes from version 1. However the overall API remains largely the same.
+[Parquet](https://parquet.apache.org) files load with `ibis.read_parquet`. For hive-partitioned data, [DuckLake](https://ducklake.select/) (`graphique.ducklake.register` / `attach`) keeps partition metadata in a catalog so DuckDB can prune and count without scanning footers. Passing a PyArrow `Dataset` as a root is deprecated.
 
 ## Usage
 There is an example app which reads a parquet dataset.
@@ -81,20 +78,23 @@ The example app uses [Starlette's config](https://www.starlette.io/config/): in
 Configuration options exist to provide a convenient no-code solution, but are subject to change in the future. Using a custom app is recommended for production usage.
 
 ### App
-For more options create a custom [ASGI](https://asgi.readthedocs.io/en/latest/index.html) app. Call graphique's `GraphQL` on an ibis [Table](https://ibis-project.org/reference/expression-tables) or arrow [Dataset](https://arrow.apache.org/docs/python/api/dataset.html).
-Use a `Query` type with dataset attributes for multiple roots, and to enable federation.
+For more options create a custom [ASGI](https://asgi.readthedocs.io/en/latest/index.html) app. Call graphique's `GraphQL` on an ibis [Table](https://ibis-project.org/reference/expression-tables).
+Use a `Query` type with table attributes for multiple roots, and to enable federation.
 
 ```python
 import ibis
 from graphique import GraphQL, typed
 
-source = ibis.read_*(...)  # or `ibis.connect(...).table(...)` or `pyarrow.dataset.dataset(...)`
-# apply initial projections or filters to `source`
-app = GraphQL(source)  # Table is root query type
+# any ibis backend: DuckDB, PostgreSQL, Polars, BigQuery, ...
+table = ibis.read_parquet(...)  # or `ibis.connect(...).table(...)`
+app = GraphQL(table)  # Table is root query type
+
 
 # multiple named fields, with optional federation keys
 class Query:
-    name = source  # or `typed(source, name, keys=...)`
+    name = table  # or `typed(table, name, keys=...)`
+
+
 app = GraphQL(Query)
 ```
 
@@ -106,7 +106,7 @@ uvicorn <module>:app
 
 ### API
 #### types
-* `Dataset`: interface for an ibis table or arrow dataset.
+* `Dataset`: GraphQL interface over an ibis table.
 * `Table`: implements the `Dataset` interface. Adds typed `row`, `columns`, and `filter` fields from introspecting the schema.
 * `Column`: interface for an ibis column. Each data type has a corresponding column implementation: Boolean, Int, BigInt, Float, Decimal, Date, Datetime, Time, Duration, Base64, String, Array, Struct. All columns have a `values` field for their list of scalars. Additional fields vary by type.
 * `Row`: scalar fields. Tables are column-oriented, and graphique encourages that usage for performance. A single `row` field is provided for convenience, but a field for a list of rows is not. Requesting parallel columns is far more efficient.
@@ -131,24 +131,23 @@ uvicorn <module>:app
 #### aggregation
 * `group`: group by given columns, and aggregate the others
 * `distinct`: group with all columns
-* `runs`: provisionally group by adjacency
+* `runs`: group by adjacency
 * `unnest`: unnest an array column
 * `count`, `any`: number of rows
 
 #### ordering
 * `order`: sort table by given columns
-* `first`: provisionally sort and filter by rank
+* `first`: sort and filter by rank
 
 #### reflection
-* `type`: type of data source
 * `schema`: field names and types
 * `optional`: nullable for errors
 * `toSql`: compiles SQL query
 
 ### Performance
-Performance is dependent on the [ibis backend](https://ibis-project.org/backends/duckdb), which defaults to [duckdb](https://duckdb.org/). There are no internal Python loops. Scalars do not become Python types until serialized. Table fields are lazily evaluated up until scalars are reached, and automatically cached as needed for multiple fields.
+Performance is dependent on the Ibis backend, which defaults to DuckDB. There are no internal Python loops. Scalars do not become Python types until serialized. Table fields are lazily evaluated up until scalars are reached, and automatically cached as needed for multiple fields.
 
-[PyArrow](https://arrow.apache.org/docs/python/) is also used for partitioned dataset optimizations. `python -m graphique.partition` is a command-line script provided in `graphique[cli]`, for out-of-core partitioning.
+For partitioned parquet datasets, [DuckLake](https://ducklake.select) provides performance benefits over `ibis.read_parquet`; see `graphique.ducklake.{register,attach}` for helpers. `python -m graphique.partition` in `graphique[cli]` writes hive-layout parquet out-of-core.
 
 ## Installation
 ```console

{graphique-2.1 → graphique-2.2}/README.md

@@ -8,14 +8,9 @@
 [![image](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 [![ty](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ty/main/assets/badge/v0.json)](https://github.com/astral-sh/ty)
 
-[GraphQL](https://graphql.org) service for [ibis](https://ibis-project.org) dataframes, [arrow](https://arrow.apache.org) tables, and [parquet](https://parquet.apache.org) datasets. The schema for a query API is derived automatically.
+[GraphQL](https://graphql.org) service for [ibis](https://ibis-project.org) tables. Ibis supports [20+ backends](https://ibis-project.org/why#how-does-ibis-work) — DuckDB, PostgreSQL, Polars, BigQuery, etc. — so the same query API works across local files and remote databases. The schema is derived automatically.
 
-## Version 2
-When this project started, there was no out-of-core execution engine with performance comparable to [PyArrow](https://arrow.apache.org/docs/python/index.html). So it effectively included one, based on datasets and [Acero](https://arrow.apache.org/docs/python/api/acero.html).
-
-Since then the ecosystem has grown considerably: [DuckDB](https://duckdb.org), [DataFusion](https://datafusion.apache.org), and [Ibis](https://ibis-project.org). As of version 2, graphique is based on `ibis`. It provides a common dataframe API for multiple backends, enabling graphique to also have a default but configurable backend.
-
-Being a major version upgrade, there are incompatible changes from version 1. However the overall API remains largely the same.
+[Parquet](https://parquet.apache.org) files load with `ibis.read_parquet`. For hive-partitioned data, [DuckLake](https://ducklake.select/) (`graphique.ducklake.register` / `attach`) keeps partition metadata in a catalog so DuckDB can prune and count without scanning footers. Passing a PyArrow `Dataset` as a root is deprecated.
 
 ## Usage
 There is an example app which reads a parquet dataset.
@@ -40,20 +35,23 @@ The example app uses [Starlette's config](https://www.starlette.io/config/): in
 Configuration options exist to provide a convenient no-code solution, but are subject to change in the future. Using a custom app is recommended for production usage.
 
 ### App
-For more options create a custom [ASGI](https://asgi.readthedocs.io/en/latest/index.html) app. Call graphique's `GraphQL` on an ibis [Table](https://ibis-project.org/reference/expression-tables) or arrow [Dataset](https://arrow.apache.org/docs/python/api/dataset.html).
-Use a `Query` type with dataset attributes for multiple roots, and to enable federation.
+For more options create a custom [ASGI](https://asgi.readthedocs.io/en/latest/index.html) app. Call graphique's `GraphQL` on an ibis [Table](https://ibis-project.org/reference/expression-tables).
+Use a `Query` type with table attributes for multiple roots, and to enable federation.
 
 ```python
 import ibis
 from graphique import GraphQL, typed
 
-source = ibis.read_*(...)  # or `ibis.connect(...).table(...)` or `pyarrow.dataset.dataset(...)`
-# apply initial projections or filters to `source`
-app = GraphQL(source)  # Table is root query type
+# any ibis backend: DuckDB, PostgreSQL, Polars, BigQuery, ...
+table = ibis.read_parquet(...)  # or `ibis.connect(...).table(...)`
+app = GraphQL(table)  # Table is root query type
+
 
 # multiple named fields, with optional federation keys
 class Query:
-    name = source  # or `typed(source, name, keys=...)`
+    name = table  # or `typed(table, name, keys=...)`
+
+
 app = GraphQL(Query)
 ```
 
@@ -65,7 +63,7 @@ uvicorn <module>:app
 
 ### API
 #### types
-* `Dataset`: interface for an ibis table or arrow dataset.
+* `Dataset`: GraphQL interface over an ibis table.
 * `Table`: implements the `Dataset` interface. Adds typed `row`, `columns`, and `filter` fields from introspecting the schema.
 * `Column`: interface for an ibis column. Each data type has a corresponding column implementation: Boolean, Int, BigInt, Float, Decimal, Date, Datetime, Time, Duration, Base64, String, Array, Struct. All columns have a `values` field for their list of scalars. Additional fields vary by type.
 * `Row`: scalar fields. Tables are column-oriented, and graphique encourages that usage for performance. A single `row` field is provided for convenience, but a field for a list of rows is not. Requesting parallel columns is far more efficient.
@@ -90,24 +88,23 @@ uvicorn <module>:app
 #### aggregation
 * `group`: group by given columns, and aggregate the others
 * `distinct`: group with all columns
-* `runs`: provisionally group by adjacency
+* `runs`: group by adjacency
 * `unnest`: unnest an array column
 * `count`, `any`: number of rows
 
 #### ordering
 * `order`: sort table by given columns
-* `first`: provisionally sort and filter by rank
+* `first`: sort and filter by rank
 
 #### reflection
-* `type`: type of data source
 * `schema`: field names and types
 * `optional`: nullable for errors
 * `toSql`: compiles SQL query
 
 ### Performance
-Performance is dependent on the [ibis backend](https://ibis-project.org/backends/duckdb), which defaults to [duckdb](https://duckdb.org/). There are no internal Python loops. Scalars do not become Python types until serialized. Table fields are lazily evaluated up until scalars are reached, and automatically cached as needed for multiple fields.
+Performance is dependent on the Ibis backend, which defaults to DuckDB. There are no internal Python loops. Scalars do not become Python types until serialized. Table fields are lazily evaluated up until scalars are reached, and automatically cached as needed for multiple fields.
 
-[PyArrow](https://arrow.apache.org/docs/python/) is also used for partitioned dataset optimizations. `python -m graphique.partition` is a command-line script provided in `graphique[cli]`, for out-of-core partitioning.
+For partitioned parquet datasets, [DuckLake](https://ducklake.select) provides performance benefits over `ibis.read_parquet`; see `graphique.ducklake.{register,attach}` for helpers. `python -m graphique.partition` in `graphique[cli]` writes hive-layout parquet out-of-core.
 
 ## Installation
 ```console

graphique-2.2/graphique/__init__.py

@@ -0,0 +1,21 @@
+from .interface import Dataset
+from .middleware import GraphQL, MetricsExtension, implement, typed
+
+
+def fetch_record_batch(self, rows_per_batch):
+    return self.to_arrow_reader(rows_per_batch)
+
+
+def connect(database=":memory:", read_only=False, config={}):
+    return original(database, read_only, {"lambda_syntax": "ENABLE_SINGLE_ARROW", **config})
+
+
+try:
+    import duckdb
+except ImportError:  # pragma: no cover
+    pass
+else:  # ibis-project/ibis#12196
+    if not hasattr(duckdb.DuckDBPyConnection, "fetch_arrow_table"):  # pragma: no branch
+        duckdb.DuckDBPyConnection.fetch_arrow_table = duckdb.DuckDBPyConnection.to_arrow_table
+        duckdb.DuckDBPyConnection.fetch_record_batch = fetch_record_batch
+        original, duckdb.connect = duckdb.connect, connect  # type: ignore

graphique-2.2/graphique/ducklake.py

@@ -0,0 +1,41 @@
+"""DuckLake helpers."""
+
+import functools
+from collections.abc import Sequence
+
+import ibis
+import pyarrow.dataset as ds
+
+
+@functools.singledispatch
+def register(
+    source: str | Sequence[str],
+    table: str,
+    *partitioning: str,
+    catalog: str = ":memory:",
+    database: str = "lake.main",
+) -> ibis.Table:
+    """Attach a DuckLake catalog and register a parquet dataset."""
+    alias, _, schema = database.partition(".")
+    con = ibis.duckdb.connect(extensions=["ducklake"])
+    con.raw_sql(f"ATTACH 'ducklake:{catalog}' AS {alias}")
+    con.create_table(table, schema=con.read_parquet(source).schema(), database=database)
+    if columns := ", ".join(partitioning):
+        con.raw_sql(f"ALTER TABLE {database}.{table} SET PARTITIONED BY ({columns})")
+    parameters = alias, table, source, schema
+    con.raw_sql("CALL ducklake_add_data_files(?, ?, ?, schema => ?)", parameters=parameters)
+    return con.table(table, database=database)
+
+
+@register.register
+def _(source: ds.Dataset, table: str, filter: ds.Expression | None = None, **kwargs) -> ibis.Table:
+    paths = [frag.path for frag in source.get_fragments(filter)]
+    return register(paths, table, *source.partitioning.schema.names, **kwargs)
+
+
+def attach(table: str, catalog: str, database: str = "lake.main") -> ibis.Table:
+    """Attach a DuckLake catalog read-only and return a table."""
+    alias, _, _ = database.partition(".")
+    con = ibis.duckdb.connect(extensions=["ducklake"])
+    con.raw_sql(f"ATTACH 'ducklake:{catalog}' AS {alias} (READ_ONLY)")
+    return con.table(table, database=database)

{graphique-2.1 → graphique-2.2}/graphique/inputs.py

@@ -4,18 +4,14 @@ GraphQL input types.
 
 from __future__ import annotations
 
-import functools
 import inspect
 import operator
 from collections.abc import Callable, Iterable, Iterator
 from datetime import date, datetime, time
 from decimal import Decimal
-from typing import Generic, TypeVar
+from typing import TypeVar
 
 import ibis.expr.types
-import pyarrow as pa
-import pyarrow.compute as pc
-import pyarrow.dataset as ds
 import strawberry
 from strawberry import UNSET
 from strawberry.annotation import StrawberryAnnotation
@@ -23,10 +19,9 @@ from strawberry.scalars import JSON
 from strawberry.schema_directive import Location
 from strawberry.types.arguments import StrawberryArgument
 
-from .core import getitems, links, order_key
-from .scalars import Duration
+from .scalars import Duration, getitems, links, order_key
 
-T = TypeVar("T")
+T = TypeVar("T")  # needed for strawberry annotation evaluation
 
 
 def use_doc(decorator: Callable, **kwargs):
@@ -43,10 +38,7 @@ class optional:
     """
 
 
-@use_doc(
-    strawberry.schema_directive,
-    locations=[Location.ARGUMENT_DEFINITION, Location.FIELD_DEFINITION, Location.OBJECT],
-)
+@use_doc(strawberry.schema_directive, locations=[Location.OBJECT])
 class provisional:
     """Provisional feature; subject to change in the future."""
 
@@ -67,7 +59,7 @@ class Field:
 
 
 @strawberry.input(description="predicates for scalars")
-class Filter(Generic[T]):
+class Filter[T]:
     eq: list[T] | None = default_field(description="== or `isin`", nullable=True)
     ne: list[T] | None = default_field(description="!= or `notin`", nullable=True)
     lt: T | None = default_field(description="<")
@@ -76,7 +68,7 @@ class Filter(Generic[T]):
     ge: T | None = default_field(description=r"\>=")
 
     def __iter__(self) -> Iterator[tuple]:
-        for name, value in self.__dict__.items():
+        for name, value in vars(self).items():
             if value is not UNSET:
                 yield name, value
 
@@ -89,15 +81,15 @@ class Filter(Generic[T]):
             else:
                 annotation = cls[scalar]  # type: ignore
             yield StrawberryArgument(name, name, StrawberryAnnotation(annotation), default={})
-        annotation = StrawberryAnnotation(Expression | None)
-        yield StrawberryArgument("where", None, annotation, default=None)
+        annotation = StrawberryAnnotation(list[Expression])
+        yield StrawberryArgument("where", None, annotation, default=[])
 
     @staticmethod
-    def to_exprs(**queries: Filter) -> Iterable[ibis.Deferred]:
+    def to_exprs(**predicates: Filter) -> Iterable[ibis.Deferred]:
         """Transform query syntax into ibis expressions."""
-        for name, query in queries.items():
+        for name, predicate in predicates.items():
             field = ibis._[name]
-            for op, value in query:
+            for op, value in predicate:
                 match value, op:
                     case list(), "eq":
                         yield field == value[0] if len(value) == 1 else field.isin(value)
@@ -108,25 +100,9 @@ class Filter(Generic[T]):
                     case _:
                         yield getattr(operator, op)(field, value)
 
-    @staticmethod
-    def to_arrow(**queries: Filter | dict) -> ds.Expression | None:
-        """Transform query syntax into an arrow expression."""
-        exprs = []
-        for name, query in queries.items():
-            field = pc.field(name)
-            for op, value in dict(query).items():
-                if isinstance(value, list):
-                    expr = pc.is_in(field, pa.array(value))
-                    exprs.append(pc.invert(expr) if op == "ne" else expr)
-                elif op == "contains":  # placeholder, will not be in partition schema
-                    exprs.append(field == value)
-                else:
-                    exprs.append(getattr(operator, op)(field, value))
-        return functools.reduce(operator.and_, exprs or [None])
-
 
 @strawberry.input(description="predicates for arrays")
-class ArrayFilter(Generic[T]):
+class ArrayFilter[T]:
     contains: T | None = default_field(description="array contains element")
 
     __iter__ = Filter.__iter__
@@ -228,8 +204,8 @@ class Aggregates:
     sum: list[Aggregate] = default_field([], func=ibis.expr.types.NumericColumn.sum)
     var: list[VarAggregate] = default_field([], func=ibis.expr.types.NumericColumn.var)
 
-    def __iter__(self) -> Iterable[tuple]:
-        for name, aggs in self.__dict__.items():
+    def __iter__(self) -> Iterator[tuple]:
+        for name, aggs in vars(self).items():
             for agg in aggs:
                 yield agg.to_ibis(name)
 
@@ -244,7 +220,7 @@ class Scalars:
     time: time | None = default_field(description="time scalar")
 
     def __iter__(self):
-        for value in self.__dict__.values():
+        for value in vars(self).values():
             if value is not UNSET:
                 yield value
 
@@ -254,9 +230,6 @@ class Expression:
     name: list[str] = default_field([], description="column name(s)")
     value: JSON | None = default_field(description="JSON scalar", nullable=True)
     scalar: Scalars | None = default_field(description="typed scalar")
-    row_number: None = default_field(
-        func=ibis.row_number, deprecation_reason="use `window.rowNumber`"
-    )
 
     eq: list[Expression] = default_field([], description="==")
     ne: list[Expression] = default_field([], description="!=")
@@ -278,21 +251,9 @@ class Expression:
     truediv: list[Expression] = default_field([], name="div", description="/")
 
     coalesce: list[Expression] = default_field([], func=ibis.Column.coalesce)
-    cume_dist: Expression | None = default_field(
-        func=ibis.Column.cume_dist, deprecation_reason="use `window.cumeDist`"
-    )
     cummax: Expression | None = default_field(func=ibis.Column.cummax)
     cummin: Expression | None = default_field(func=ibis.Column.cummin)
-    dense_rank: Expression | None = default_field(
-        func=ibis.Column.dense_rank, deprecation_reason="use `window.denseRank`"
-    )
     ifelse: list[Expression] = default_field([], func=ibis.expr.types.BooleanColumn.ifelse)
-    percent_rank: Expression | None = default_field(
-        func=ibis.Column.percent_rank, deprecation_reason="use `window.percentRank`"
-    )
-    rank: Expression | None = default_field(
-        func=ibis.Column.rank, deprecation_reason="use `window.rank`"
-    )
 
     array: Arrays | None = default_field(description="array value functions")
     numeric: Numeric | None = default_field(description="numeric functions")
@@ -301,21 +262,19 @@ class Expression:
     window: Window | None = default_field(description="window functions")
 
     def items(self) -> Iterable[tuple]:
-        for name, value in self.__dict__.items():
+        for name, value in vars(self).items():
             if isinstance(value, Expression):
                 yield name, [value.to_ibis()]
             elif isinstance(value, list) and value and isinstance(value[0], Expression):
                 yield name, map(Expression.to_ibis, value)
 
-    def __iter__(self) -> Iterable[ibis.Deferred]:
+    def __iter__(self):
         if self.name:
             yield getitems(ibis._, *self.name)
         if self.value is not UNSET:
             yield self.value
         if self.scalar:
             yield from self.scalar
-        if self.row_number is not UNSET:
-            yield ibis.row_number()
         for name, (expr, *args) in self.items():
             match name:
                 case "eq" | "ne" | "lt" | "le" | "gt" | "ge" | "inv" | "and_" | "or_" | "xor":
@@ -328,11 +287,11 @@ class Expression:
             if field:
                 yield from field
 
-    def to_ibis(self) -> ibis.Deferred | None:
+    def to_ibis(self) -> ibis.Deferred:
         fields = list(self)
-        if len(fields) > 1:
-            raise ValueError("conflicting inputs: " + ", ".join(map(str, fields)))
-        return next(iter(fields), None)  # type: ignore
+        if len(fields) == 1:
+            return fields[0]
+        raise ValueError(f"'Expression' must specify one key (found {len(fields)})")
 
 
 @strawberry.input(description="an `Expression` with an optional alias")
@@ -340,10 +299,9 @@ class Projection(Expression):
     alias: str = strawberry.field(default="", description="name of projected column")
 
     def to_ibis(self) -> tuple:  # type: ignore
-        name = self.alias or ".".join(self.name)
-        if name:
+        if name := self.alias or ".".join(self.name):
             return name, super().to_ibis()
-        raise ValueError(f"projected fields require a name or alias: {self}")
+        raise ValueError("'Projection' must specify a name or alias")
 
 
 @strawberry.input(description=f"array [expressions]({links.ref}/expression-collections)")