goldeneye: generate the SQLite dialect from the official sqlite3 shell

Add a sqlite package to goldeneye that reads pragma_function_list from
the sqlite3 shell sqlite.org publishes, run against an in-memory
database, and writes internal/engine/sqlite/dialect/functions.jsonl
from it. `install sqlite` downloads the pinned release (3.53.4, the one
the ncruces/go-sqlite3 driver embeds) into the user cache directory and
checks it against the SHA3-256 the download page lists, the same way
the clickhouse installer works; SQLITE3 names a shell to use instead.

SQLite records a function's name, kind and argument count and nothing
about types, so the return and argument types come from a table in
sqlite/signatures.go. A built-in function the shell reports that the
table lacks fails the run, as does a table entry the shell does not
report. Aggregates are told apart from window functions by calling each
without OVER, since SQLite marks every aggregate 'w'. SQLite has no
catalog of types or operators, so those files stay hand-written.

Regenerating the committed file adds the JSON, date and time, window
and percentile functions the hand-written list lacked, corrects the
misspelled random and randomblob entries, marks group_concat nullable
as it is over no rows, and drops soundex, which the official build
does not compile in. The goldens that move follow from those.

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

Author: claude

.github/workflows/gen.yml

@@ -24,6 +24,8 @@ jobs:
         check-latest: true
     - run: go run ./cmd/goldeneye install clickhouse
       working-directory: internal/goldeneye
+    - run: go run ./cmd/goldeneye install sqlite
+      working-directory: internal/goldeneye
     - run: go run ./cmd/goldeneye generate
       working-directory: internal/goldeneye
       env:

CLAUDE.md

@@ -153,6 +153,7 @@ 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 sqlite       # download the pinned sqlite3 shell once
 POSTGRESQL_SERVER_URI="postgres://postgres:postgres@127.0.0.1:5432/postgres?sslmode=disable" go test ./...
 go run ./cmd/goldeneye generate postgresql  # rewrite the files after a change
 ```

internal/endtoend/testdata/builtins/sqlite/go/aggfunc.sql.go

@@ -5,13 +5,8 @@ import (
 )
 
 // defaultSchema is SQLite's standard library, read from the dialect
-// directory's functions.jsonl.
-//
-// The functions are drawn from:
-//
-//	https://www.sqlite.org/lang_aggfunc.html
-//	https://www.sqlite.org/lang_mathfunc.html
-//	https://www.sqlite.org/lang_corefunc.html
+// directory's functions.jsonl, which internal/goldeneye generates from the
+// sqlite3 shell's pragma_function_list.
 func defaultSchema(name string) *catalog.Schema {
 	return &catalog.Schema{Name: name, Funcs: stdlib()}
 }

internal/endtoend/testdata/builtins/sqlite/go/scalarfunc.sql.go

@@ -15,6 +15,7 @@ reads 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 sqlite       # download the pinned sqlite3 shell once
 go run ./cmd/goldeneye check                # check every engine whose database is available
 go run ./cmd/goldeneye check postgresql     # check one engine
 go run ./cmd/goldeneye generate [engine]    # rewrite the generated files from the database
@@ -54,14 +55,29 @@ the hand-written files alone, and the checks do not look at them.
   `clickhouse/install.go`, and a download that does not match is discarded.
   ClickHouse describes its functions no further than their names, so
   `functions.jsonl` is hand-written.
+- **`sqlite`** needs no server either: `functions.jsonl` comes from
+  `pragma_function_list` of the `sqlite3` shell sqlite.org publishes, run
+  against an in-memory database. SQLite describes its functions as far as
+  their names, their kinds and the number of arguments each overload takes,
+  and no further — it types values, not functions — so what each returns and
+  what its arguments hold comes from the table in `sqlite/signatures.go`,
+  and a built-in function the shell reports that the table does not know
+  fails the run rather than being guessed at. The shell is downloaded once
+  per pinned release by `install` into the user cache directory, or supplied
+  through the `SQLITE3` environment variable; the pinned release, which is
+  the one the main module's driver embeds, and the SHA3-256 of each
+  platform's download live in `sqlite/install.go`. SQLite has no catalog of
+  types or operators, so `types.jsonl` and `operators.jsonl` are
+  hand-written.
 
 ## Layout
 
 - `dialect/` — the record types the files are made of, mirrored from
   `internal/core/seed`, and the helpers that write a generated set of files
   into an engine directory or diff it against what is committed.
-- `postgresql/`, `duckdb/`, `clickhouse/` — one package per engine, each
-  exposing `Locate`, `Version` and `Generate`, and a test that runs the check.
+- `postgresql/`, `duckdb/`, `clickhouse/`, `sqlite/` — one package per
+  engine, each exposing `Locate`, `Version` and `Generate`, and a test that
+  runs the check.
 - `cmd/goldeneye/` — the command.
 
 The analysis checks — verifying the `analyze_*` cases under

internal/endtoend/testdata/table_function/sqlite/go/query.sql.go

@@ -5,6 +5,7 @@
 // Usage, from internal/goldeneye:
 //
 //	go run ./cmd/goldeneye install clickhouse   # download the pinned clickhouse binary
+//	go run ./cmd/goldeneye install sqlite       # download the pinned sqlite3 shell
 //	go run ./cmd/goldeneye generate [engine]    # rewrite the generated files from the database
 //	go run ./cmd/goldeneye check [engine]       # compare the committed files with the database
 //
@@ -26,6 +27,7 @@ import (
 	"github.com/sqlc-dev/sqlc/internal/goldeneye/dialect"
 	"github.com/sqlc-dev/sqlc/internal/goldeneye/duckdb"
 	"github.com/sqlc-dev/sqlc/internal/goldeneye/postgresql"
+	"github.com/sqlc-dev/sqlc/internal/goldeneye/sqlite"
 )
 
 func main() {
@@ -36,14 +38,14 @@ func main() {
 }
 
 const usage = `usage:
-  goldeneye install clickhouse [-version V]
-      download the pinned clickhouse binary into the user cache directory
+  goldeneye install clickhouse|sqlite [-version V]
+      download the pinned binary for an engine into the user cache directory
   goldeneye generate [engine]
       rewrite the generated dialect files from the database, for every available engine or one
   goldeneye check [engine]
       compare the committed dialect files with the database, for every available engine or one
 
-engines: clickhouse, duckdb, postgresql`
+engines: clickhouse, duckdb, postgresql, sqlite`
 
 // engine is one database goldeneye knows how to read a dialect from.
 type engine struct {
@@ -61,6 +63,19 @@ var engines = []engine{
 	{clickhouse.Engine, clickhouse.Locate, clickhouse.Version, clickhouse.Generate},
 	{duckdb.Engine, duckdb.Locate, duckdb.Version, duckdb.Generate},
 	{postgresql.Engine, postgresql.Locate, postgresql.Version, postgresql.Generate},
+	{sqlite.Engine, sqlite.Locate, sqlite.Version, sqlite.Generate},
+}
+
+// installer downloads the binary an engine is read through, for the engines
+// that need no server and whose release is pinned in their package.
+type installer struct {
+	defaultVersion string
+	install        func(ctx context.Context, version, goos, goarch string, progress io.Writer) (string, error)
+}
+
+var installers = map[string]installer{
+	clickhouse.Engine: {clickhouse.DefaultVersion, clickhouse.Install},
+	sqlite.Engine:     {sqlite.DefaultVersion, sqlite.Install},
 }
 
 func run(ctx context.Context, args []string, stdout, stderr io.Writer) error {
@@ -84,16 +99,20 @@ 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 || args[0] != clickhouse.Engine {
-		return errors.New("install takes the engine to install: clickhouse")
+	if len(args) == 0 {
+		return errors.New("install takes the engine to install: clickhouse 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])
 	}
-	fs := flag.NewFlagSet("install", flag.ContinueOnError)
+	fs := flag.NewFlagSet("install "+args[0], flag.ContinueOnError)
 	fs.SetOutput(stderr)
-	version := fs.String("version", clickhouse.DefaultVersion, "ClickHouse release to install")
+	version := fs.String("version", inst.defaultVersion, args[0]+" release to install")
 	if err := fs.Parse(args[1:]); err != nil {
 		return err
 	}
-	path, err := clickhouse.Install(ctx, *version, runtime.GOOS, runtime.GOARCH, stderr)
+	path, err := inst.install(ctx, *version, runtime.GOOS, runtime.GOARCH, stderr)
 	if err != nil {
 		return err
 	}