goldeneye: install DuckDB 2.0 preview builds and check its analyze cases

DuckDB 2.0 has no release to download yet, so `install duckdb` fetches
the current build of DuckDB's v2.0 preview channel, a rolling tarball
per platform with no per-build download and no checksum to pin, into
the user cache directory, where Locate finds it after DUCKDB and before
PATH. GeneratedFrom records the build the dialect was generated from,
and the dialect is regenerated from the channel's current build, which
adds a few functions and lists each type alias once per schema it is
visible in, which the generator now folds.

The duckdb engine gains an analysis check over the DuckDB analyze cases.
The CLI reports a parameter's type through the unoptimized logical plan
of the prepared query explained with a string sentinel bound to each
parameter, and a result column's name and type through DESCRIBE with a
typed NULL in each parameter's place; it prints every column by its bare
name, so which table a result column is read from and which column a
parameter stands in for come from the query text resolved against the
catalog, and since it tracks no nullability of expressions, the query is
run over the fixture and over no rows to see which columns come back
NULL. A spelling the generated types.jsonl lists as an alias, such as
json for varchar, is reported by the dialect's name for it.

The gen workflow gets a duckdb job that installs and generates from the
channel, and the README and CLAUDE.md describe the engine.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01F7cPsawATXMfiYqWg8nBVb

Author: claude

.github/workflows/gen.yml

@@ -166,3 +166,27 @@ jobs:
         path: internal/engine/googlesql/dialect
     - name: Fail if the committed dialect differs
       run: git add -N internal/engine/googlesql && git diff --exit-code --stat -- internal/engine/googlesql
+
+  duckdb:
+    name: generate duckdb dialect
+    runs-on: ubuntu-24.04
+    steps:
+    - uses: actions/checkout@v7
+    - uses: actions/setup-go@v7
+      with:
+        go-version-file: internal/goldeneye/go.mod
+        check-latest: true
+    # The current build of DuckDB's v2.0 preview channel, until 2.0 is
+    # released: a later build than the dialect was generated from shows up
+    # as a difference.
+    - run: go run ./cmd/goldeneye install duckdb
+      working-directory: internal/goldeneye
+    - run: go run ./cmd/goldeneye generate duckdb
+      working-directory: internal/goldeneye
+    - name: Save results
+      uses: actions/upload-artifact@v7
+      with:
+        name: dialect-duckdb
+        path: internal/engine/duckdb/dialect
+    - name: Fail if the committed dialect differs
+      run: git add -N internal/engine/duckdb && git diff --exit-code --stat -- internal/engine/duckdb

CLAUDE.md

@@ -150,13 +150,14 @@ from a live database by `/internal/goldeneye`, a nested module, and its tests
 verify the committed files against one byte for byte. The same module checks
 the `analyze_*` cases under `/internal/endtoend/testdata/` against what the
 database itself reports for them, so a `fixture.sql` next to a case's schema
-gives the queries rows to run against. ClickHouse, MySQL, SQLite, SQL Server
-and Spanner have the check today; engines whose database is not available
-skip.
+gives the queries rows to run against. ClickHouse, DuckDB, MySQL, SQLite,
+SQL Server and Spanner have the check today; engines whose database is not
+available skip.
 
 ```bash
 cd internal/goldeneye
 go run ./cmd/goldeneye install clickhouse   # download the pinned clickhouse binary once
+go run ./cmd/goldeneye install duckdb       # download the current DuckDB 2.0 preview build once
 go run ./cmd/goldeneye install sqlite       # build the pinned sqlite3 shells once; needs a C compiler
 POSTGRESQL_SERVER_URI="postgres://postgres:postgres@127.0.0.1:5432/postgres?sslmode=disable" \
 MYSQL_SERVER_URI="root:mysecretpassword@tcp(127.0.0.1:3306)/mysql" \

internal/engine/duckdb/dialect/functions.jsonl

@@ -1,5 +1,6 @@
 {"name":"__between","args":[{"type":"any"},{"type":"any"},{"type":"any"}],"returns":"boolean"}
 {"name":"__cast","args":[{"type":"any"}],"returns":"any"}
+{"name":"__internal_barrier","args":[{"type":"any"}],"returns":"any"}
 {"name":"__internal_compress_geometry_point","args":[{"type":"geometry"}],"returns":"uhugeint"}
 {"name":"__internal_compress_integral_ubigint","args":[{"type":"hugeint"},{"type":"hugeint"}],"returns":"ubigint"}
 {"name":"__internal_compress_integral_ubigint","args":[{"type":"uhugeint"},{"type":"uhugeint"}],"returns":"ubigint"}
@@ -2198,6 +2199,7 @@
 {"name":"regexp_extract","args":[{"type":"varchar"},{"type":"varchar"},{"type":"varchar[]"}],"returns":"varchar"}
 {"name":"regexp_extract","args":[{"type":"varchar"},{"type":"varchar"},{"type":"integer"},{"type":"varchar"}],"returns":"varchar"}
 {"name":"regexp_extract","args":[{"type":"varchar"},{"type":"varchar"},{"type":"integer"}],"returns":"varchar"}
+{"name":"regexp_extract","args":[{"type":"varchar"},{"type":"varchar"},{"type":"varchar"}],"returns":"varchar"}
 {"name":"regexp_extract","args":[{"type":"varchar"},{"type":"varchar"}],"returns":"varchar"}
 {"name":"regexp_extract_all","args":[{"type":"varchar"},{"type":"varchar"},{"type":"varchar[]"},{"type":"varchar"}],"returns":"varchar[]"}
 {"name":"regexp_extract_all","args":[{"type":"varchar"},{"type":"varchar"},{"type":"varchar[]"}],"returns":"varchar[]"}
@@ -2278,6 +2280,22 @@
 {"name":"round","args":[{"type":"smallint"}],"returns":"smallint"}
 {"name":"round","args":[{"type":"tinyint"},{"type":"integer"}],"returns":"tinyint"}
 {"name":"round","args":[{"type":"tinyint"}],"returns":"tinyint"}
+{"name":"round_even","args":[{"type":"bigint"},{"type":"integer"}],"returns":"bigint"}
+{"name":"round_even","args":[{"type":"decimal"},{"type":"integer"}],"returns":"decimal"}
+{"name":"round_even","args":[{"type":"double"},{"type":"integer"}],"returns":"double"}
+{"name":"round_even","args":[{"type":"float"},{"type":"integer"}],"returns":"float"}
+{"name":"round_even","args":[{"type":"hugeint"},{"type":"integer"}],"returns":"hugeint"}
+{"name":"round_even","args":[{"type":"integer"},{"type":"integer"}],"returns":"integer"}
+{"name":"round_even","args":[{"type":"smallint"},{"type":"integer"}],"returns":"smallint"}
+{"name":"round_even","args":[{"type":"tinyint"},{"type":"integer"}],"returns":"tinyint"}
+{"name":"roundbankers","args":[{"type":"bigint"},{"type":"integer"}],"returns":"bigint"}
+{"name":"roundbankers","args":[{"type":"decimal"},{"type":"integer"}],"returns":"decimal"}
+{"name":"roundbankers","args":[{"type":"double"},{"type":"integer"}],"returns":"double"}
+{"name":"roundbankers","args":[{"type":"float"},{"type":"integer"}],"returns":"float"}
+{"name":"roundbankers","args":[{"type":"hugeint"},{"type":"integer"}],"returns":"hugeint"}
+{"name":"roundbankers","args":[{"type":"integer"},{"type":"integer"}],"returns":"integer"}
+{"name":"roundbankers","args":[{"type":"smallint"},{"type":"integer"}],"returns":"smallint"}
+{"name":"roundbankers","args":[{"type":"tinyint"},{"type":"integer"}],"returns":"tinyint"}
 {"name":"row","args":[{"type":"any","mode":"v"}],"returns":"tuple"}
 {"name":"row_number","kind":"w","returns":"bigint"}
 {"name":"row_to_json","args":[{"type":"any","mode":"v"}],"returns":"json"}
@@ -2457,7 +2475,9 @@
 {"name":"timezone","args":[{"type":"time_ns"}],"returns":"bigint"}
 {"name":"timezone","args":[{"type":"varchar"},{"type":"time with time zone"}],"returns":"time with time zone"}
 {"name":"timezone","args":[{"type":"varchar"},{"type":"timestamp with time zone"}],"returns":"timestamp"}
+{"name":"timezone","args":[{"type":"varchar"},{"type":"timestamptz_ns"}],"returns":"timestamp_ns"}
 {"name":"timezone","args":[{"type":"varchar"},{"type":"timestamp"}],"returns":"timestamp with time zone"}
+{"name":"timezone","args":[{"type":"varchar"},{"type":"timestamp_ns"}],"returns":"timestamptz_ns"}
 {"name":"timezone_hour","args":[{"type":"date"}],"returns":"bigint"}
 {"name":"timezone_hour","args":[{"type":"interval"}],"returns":"bigint"}
 {"name":"timezone_hour","args":[{"type":"time with time zone"}],"returns":"bigint"}
@@ -2580,6 +2600,7 @@
 {"name":"variant_extract","args":[{"type":"variant"},{"type":"varchar"}],"returns":"variant"}
 {"name":"variant_extract_string","args":[{"type":"variant"},{"type":"varchar[]"}],"returns":"varchar[]"}
 {"name":"variant_extract_string","args":[{"type":"variant"},{"type":"varchar"}],"returns":"varchar"}
+{"name":"variant_group_object","kind":"a","args":[{"type":"varchar"},{"type":"variant"}],"returns":"variant","nullable":true}
 {"name":"variant_keys","args":[{"type":"variant"},{"type":"varchar[]"}],"returns":"varchar[][]"}
 {"name":"variant_keys","args":[{"type":"variant"},{"type":"varchar"}],"returns":"varchar[]"}
 {"name":"variant_keys","args":[{"type":"variant"}],"returns":"varchar[]"}

internal/goldeneye/README.md

@@ -16,6 +16,7 @@ the files: the files are the contract. Run it from this directory:
 
 ```bash
 go run ./cmd/goldeneye install clickhouse   # download the pinned clickhouse binary once
+go run ./cmd/goldeneye install duckdb       # download the current DuckDB 2.0 preview build once
 go run ./cmd/goldeneye install sqlite       # build the pinned sqlite3 shells once; needs a C compiler
 go run ./cmd/goldeneye check                # check every engine whose database is available
 go run ./cmd/goldeneye check postgresql     # check one engine
@@ -61,10 +62,20 @@ the hand-written files alone, and the checks do not look at them.
   knows a system schema when it sees one. The server has to be the major
   release pinned in `mysql.Major`, since every release adds to
   `information_schema`.
-- **`duckdb`** reads the DuckDB CLI named by `DUCKDB`, or `duckdb` on `PATH`:
-  `types.jsonl`, `functions.jsonl` and `operators.jsonl` come from
-  `duckdb_types()` and `duckdb_functions()`. The CLI has to be the DuckDB 2.0
-  build darkwing is pinned against, which has no release to download yet.
+- **`duckdb`** reads the DuckDB CLI named by `DUCKDB`, or the one `install`
+  put in the user cache directory, or `duckdb` on `PATH`: `types.jsonl`,
+  `functions.jsonl` and `operators.jsonl` come from `duckdb_types()` and
+  `duckdb_functions()`. The CLI has to be a DuckDB 2.0 build, the release
+  darkwing is pinned against, which has no release to download yet: until
+  2.0 is out, `install` downloads the current build of DuckDB's v2.0
+  preview channel, `duckdb.DefaultVersion`, a rolling tarball per platform
+  under `artifacts.duckdb.org` with no per-build download and no checksum
+  to pin, so what a run logs is the version the CLI reports, and
+  `duckdb.GeneratedFrom` records the build the committed dialect came
+  from. A check against a later build reports what the later build added;
+  regenerate, and update `GeneratedFrom`, to move the dialect along. Once
+  2.0 is released, the installer should pin the release and its checksums
+  the way the clickhouse one does.
 - **`clickhouse`** needs no server: `types.jsonl` comes from
   `system.data_type_families` of an ephemeral `clickhouse local` process,
   every family that is not an alias becoming a type carrying the spellings
@@ -232,6 +243,34 @@ asks for `--ast` is skipped, since only sqlc can print that.
   is why a column read from a table, directly or through a derived table,
   is spelled the way the table declares it.
 
+- **`duckdb`** runs each case through the CLI, which loads the schema and
+  fixture into an in-memory database of their own, one process per
+  question, and is asked four things about each query. What its
+  parameters are: the query is prepared and explained with a string
+  sentinel bound to each parameter, `EXECUTE q('goldeneye_1', ...)`, and
+  the unoptimized logical plan the CLI prints under
+  `explain_output = 'all'` shows each as `CAST('goldeneye_k' AS T)`, `T`
+  being the type the binder gave the parameter; a sentinel the binder
+  converts on the spot, as an `INSERT`'s `VALUES` are, is bound to NULL
+  instead. What its result columns are: `DESCRIBE`, with each parameter
+  replaced by a NULL of its type, names and types them; DuckDB describes
+  no DML, so a `RETURNING` column is the target table's column it names.
+  Which table a result column is read from and which column a parameter
+  stands in for: DuckDB prints a plan with every column by its bare name
+  and every aliased expression by its alias, so these are read from the
+  query text, the select list's items, a star expanded to its table's
+  columns, and the operand beside each parameter, resolved against the
+  `FROM` clause and the catalog, `duckdb_columns()`, from which a column
+  read from a table takes its declared type and nullability; a parameter
+  the query casts takes the cast's type as DuckDB spells it. And whether
+  an expression can be NULL, which DuckDB does not track: the query is
+  run, with each parameter bound to a value of its type, over the fixture
+  and over no rows, and a column is nullable when either run returns a
+  NULL for it. DuckDB spells an enum column by its labels whether the
+  schema named the type or not, so labels that are those of an enum the
+  schema created name that type, and a spelling `types.jsonl` lists as an
+  alias — `json`, which DuckDB's own catalog lists as a spelling of
+  `varchar` — is reported by the dialect's name for it.
 - **`mssql`** describes each case in a database of its own on the server
   named by `MSSQL_SERVER_URI`, without running anything: the schema is
   loaded one statement at a time, since a `CREATE TYPE` has to be its own

internal/goldeneye/cmd/goldeneye/main.go

@@ -6,6 +6,7 @@
 // Usage, from internal/goldeneye:
 //
 //	go run ./cmd/goldeneye install clickhouse   # download the pinned clickhouse binary
+//	go run ./cmd/goldeneye install duckdb       # download the current DuckDB 2.0 preview build
 //	go run ./cmd/goldeneye install sqlite       # build the pinned sqlite3 shells from source
 //	go run ./cmd/goldeneye generate [engine]    # rewrite the generated files from the database
 //	go run ./cmd/goldeneye check [engine]       # compare the committed files and analyze cases with the database
@@ -44,9 +45,10 @@ func main() {
 }
 
 const usage = `usage:
-  goldeneye install clickhouse|sqlite [-version V]
+  goldeneye install clickhouse|duckdb|sqlite [-version V]
       put the pinned release of an engine into the user cache directory: clickhouse is
-      downloaded, sqlite is built from the downloaded amalgamation with cc or $CC
+      downloaded, duckdb is downloaded from its v2.0 preview channel, sqlite is built from
+      the downloaded amalgamation with cc or $CC
   goldeneye generate [engine]
       rewrite the generated dialect files from the database, for every available engine or one
   goldeneye check [engine]
@@ -81,7 +83,7 @@ type engine struct {
 
 var engines = []engine{
 	{clickhouse.Engine, "", "", clickhouse.Locate, clickhouse.Version, clickhouse.Generate, clickhouse.Analyze},
-	{duckdb.Engine, "", "", duckdb.Locate, duckdb.Version, duckdb.Generate, nil},
+	{duckdb.Engine, "", "", duckdb.Locate, duckdb.Version, duckdb.Generate, duckdb.Analyze},
 	{mssql.Engine, "", "", mssql.Locate, mssql.Version, mssql.Generate, mssql.Analyze},
 	{mysql.Engine, mysql.Dir, "", mysql.Locate, mysql.Version, mysql.Generate, mysql.Analyze},
 	{postgresql.Engine, "", "", postgresql.Locate, postgresql.Version, postgresql.Generate, nil},
@@ -106,6 +108,7 @@ type installer struct {
 
 var installers = map[string]installer{
 	clickhouse.Engine: {clickhouse.DefaultVersion, clickhouse.Install},
+	duckdb.Engine:     {duckdb.DefaultVersion, duckdb.Install},
 	sqlite.Engine:     {sqlite.DefaultVersion, sqlite.Install},
 }
 
@@ -131,11 +134,11 @@ func run(ctx context.Context, args []string, stdout, stderr io.Writer) error {
 
 func install(ctx context.Context, args []string, stdout, stderr io.Writer) error {
 	if len(args) == 0 {
-		return errors.New("install takes the engine to install: clickhouse or sqlite")
+		return errors.New("install takes the engine to install: clickhouse, duckdb or sqlite")
 	}
 	inst, ok := installers[args[0]]
 	if !ok {
-		return fmt.Errorf("install takes the engine to install, clickhouse or sqlite, not %q", args[0])
+		return fmt.Errorf("install takes the engine to install, clickhouse, duckdb or sqlite, not %q", args[0])
 	}
 	fs := flag.NewFlagSet("install "+args[0], flag.ContinueOnError)
 	fs.SetOutput(stderr)