fix(sqlite): preserve SQLite URI params through finalizer (#18)

* fix(sqlite): preserve SQLite URI params through finalizer

The `finalizerSQLite` stripped any DSN query param not in `moderncSQLiteParams`,
with a comment claiming that set was the "complete" list of params recognised
by modernc.org/sqlite. That's true for Go-driver params (_pragma etc.), but
the list also needed SQLite's own URI params — `mode`, `cache`, `psow`,
`nolock`, `immutable` — which SQLite parses itself when SQLITE_OPEN_URI is
set (modernc enables it unconditionally in conn.go).

Without this, a DSN like `file:name?mode=memory&cache=shared` had `mode` and
`cache` dropped before reaching modernc, causing sqlite3_open_v2 to fall back
to creating an on-disk file named `name` instead of an in-memory database.

Downstream impact: Hydra and other services that use `DSN=memory` to
construct `file:<random>?mode=memory&cache=shared` ended up with stray SQLite
files accumulating in the working directory after each process start.

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hperl

dialect_sqlite.go

@@ -368,9 +368,18 @@ var sqliteInternalKeys = map[string]bool{
 }
 
 // moderncSQLiteParams is the complete set of DSN query parameters recognised
-// by modernc.org/sqlite. Any key not in this set will be warned and stripped.
-// Source: modernc.org/sqlite@v1.47.0/sqlite.go applyQueryParams() and
-// modernc.org/sqlite@v1.47.0/conn.go newConn().
+// by modernc.org/sqlite or by SQLite itself via SQLITE_OPEN_URI. Any key not
+// in this set will be warned and stripped.
+//
+// Go driver params (modernc.org/sqlite@v1.48.0/sqlite.go applyQueryParams()
+// and conn.go newConn()):
+//   - vfs, _pragma, _time_format, _txlock, _time_integer_format, _inttotime,
+//     _texttotime
+//
+// SQLite URI params (https://sqlite.org/uri.html) — processed by SQLite
+// itself when the DSN starts with "file:" and SQLITE_OPEN_URI is set, which
+// modernc.org/sqlite enables unconditionally:
+//   - mode, cache, psow, nolock, immutable
 var moderncSQLiteParams = map[string]bool{
 	"vfs":                  true, // VFS name
 	"_pragma":              true, // PRAGMA name(value); repeatable
@@ -379,6 +388,11 @@ var moderncSQLiteParams = map[string]bool{
 	"_time_integer_format": true, // integer time repr: unix/unix_milli/unix_micro/unix_nano
 	"_inttotime":           true, // convert integer columns to time.Time
 	"_texttotime":          true, // affect ColumnTypeScanType for TEXT date columns
+	"mode":                 true, // SQLite URI: ro | rw | rwc | memory
+	"cache":                true, // SQLite URI: shared | private
+	"psow":                 true, // SQLite URI: powersafe overwrite
+	"nolock":               true, // SQLite URI: disable locking
+	"immutable":            true, // SQLite URI: read-only, no change check
 }
 
 func finalizerSQLite(cd *ConnectionDetails) {

dialect_sqlite_test.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 	"fmt"
 	"net/url"
+	"os"
 	"path/filepath"
 	"testing"
 	"time"
@@ -546,6 +547,57 @@ func Test_ConnectionDetails_Finalize_SQLite_Programmatic(t *testing.T) {
 	require.Equal(t, "1", cd.Options["_fk"])
 }
 
+// Test_ConnectionDetails_Finalize_SQLite_URIParams verifies that SQLite URI
+// query parameters (mode, cache, psow, nolock, immutable) are preserved in
+// RawOptions. These are processed by SQLite itself when SQLITE_OPEN_URI is
+// set — modernc.org/sqlite passes the URI through unchanged — and stripping
+// them breaks `mode=memory` in-memory databases by falling back to disk files
+// named after the URI path.
+func Test_ConnectionDetails_Finalize_SQLite_URIParams(t *testing.T) {
+	for _, tc := range []struct {
+		key, value string
+	}{
+		{"mode", "memory"},
+		{"cache", "shared"},
+		{"psow", "0"},
+		{"nolock", "1"},
+		{"immutable", "1"},
+	} {
+		t.Run(tc.key, func(t *testing.T) {
+			cd := &ConnectionDetails{
+				URL: fmt.Sprintf("sqlite3://file:x?%s=%s", tc.key, tc.value),
+			}
+			require.NoError(t, cd.Finalize())
+			q, err := url.ParseQuery(cd.RawOptions)
+			require.NoError(t, err)
+			require.Equal(t, tc.value, q.Get(tc.key),
+				"SQLite URI param %q=%q must survive finalizer", tc.key, tc.value)
+		})
+	}
+}
+
+// Test_ConnectionDetails_Finalize_SQLite_MemoryDSNStaysInMemory opens a DSN
+// with mode=memory&cache=shared and asserts no file is created on disk.
+// Regression test for the bug where finalizerSQLite stripped SQLite URI
+// params, causing in-memory DSNs to silently fall back to disk files.
+func Test_ConnectionDetails_Finalize_SQLite_MemoryDSNStaysInMemory(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "memtest")
+	cd := &ConnectionDetails{
+		URL: fmt.Sprintf("sqlite3://file:%s?mode=memory&cache=shared", dbPath),
+	}
+	require.NoError(t, cd.Finalize())
+
+	db, err := sql.Open("sqlite3", cd.Database+"?"+cd.RawOptions)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = db.Close() })
+	_, err = db.Exec("CREATE TABLE t(x INT); INSERT INTO t VALUES (1)")
+	require.NoError(t, err)
+
+	_, err = os.Stat(dbPath)
+	require.True(t, os.IsNotExist(err),
+		"mode=memory DSN must not create an on-disk file at %q", dbPath)
+}
+
 // Test_ConnectionDetails_Finalize_SQLite_DirectPragma verifies that
 // _pragma=name(value) entries set directly in the DSN survive and are echoed.
 func Test_ConnectionDetails_Finalize_SQLite_DirectPragma(t *testing.T) {