This module provides the glue needed to reuse the existing ToField/FromField machinery with algebraic data types via GHC generics. The supported mapping is currently intentionally conservative:

• Product types (records or tuples) whose fields already satisfy DuckValue are encoded as STRUCT values. Record fields retain their selector name; positional products fall back to field1, field2, …
• Sum types (:+:) become UNION values. Each constructor becomes a union member; payloads are encoded as structs (or NULL for nullary constructors).

Recursive types are supported as long as every payload is itself encodable through DuckValue. Note that sum types must have constructor fields that are structural products (i.e. we do not yet expose mixed union/record nesting for non-record constructors).

Typical usage looks like:

data User = User { userId :: Int64, userName :: Text }
  deriving stock (Generic)

instance DuckValue User

toField (genericToFieldValue user) -- Struct {"userId" := ..., ...}

For sum types:

data Shape
  = Circle Double
  | Rectangle Double Double
  | Origin
  deriving stock (Generic)

instance DuckValue Shape

Constructors are turned into a union with members Circle{radius}, Rectangle{width,height}, and Origin (null payload).

You can also lean on DerivingVia using the exported ViaDuckDB newtype:

data User = User { userId :: Int64, userName :: Text }
  deriving stock (Generic)
  deriving (DuckDBColumnType, ToField, FromField) via (ViaDuckDB User)

The derived instances automatically encodedecode via STRUCTUNION representations.

Extending this module

The rest of this file is organised so that each building block is reusable:

• DuckValue covers leaf-level conversions between Haskell values, DuckDB FieldValues, and logical type metadata.
• GToField and friends walk the generic representation to assemble structs or unions and carry around the logical type information we later need when binding parameters.
• ViaDuckDB wires everything together for deriving via.

When adding new features, mimic the structure used here (and document new classes the way the existing ones are documented) so other backends can take inspiration from this implementation.