fix(db): rewrite ILIKE for SQLite, and stop tracking database sidecars

docs/databases.md

@@ -58,6 +58,7 @@ tables.**
 | `numeric(p,s)` | `REAL` (NUMERIC affinity demotes integers and breaks float64 scans) |
 | `bytea` | `BLOB` |
 | `EXTRACT(EPOCH FROM CURRENT_TIMESTAMP)::bigint` | `(unixepoch())` |
+| `ILIKE` | `LIKE`, rewritten in the driver (see below) |
 | `now()` | `CURRENT_TIMESTAMP` |
 | `TRIM(BOTH FROM x)` | `TRIM(x)` |
 | `char_length` | `length` |
@@ -148,13 +149,27 @@ only emits those for zero values, and `BeforeAppendModel` sets the fields first.
 A file that is deliberately Postgres-only opts out with a `dialect:postgres-only`
 marker near its package clause, and must gate itself on a capability instead.
 
+### ILIKE
+
+`ILIKE` is rewritten to `LIKE` in the SQLite driver rather than at the call site.
+It appears in roughly fifty places, and almost none of them can be fixed where
+they are written: `buncolgen` and `querybuilder` precompute their SQL fragments
+into package-level values at init, before configuration is read, and most of
+`buncolgen` is generated. The driver is the only single point that covers all of
+them.
+
+The substitution is sound because SQLite's `LIKE` is already case-insensitive for
+ASCII, which is what `ILIKE` is used for here. It is **not** equivalent for
+non-ASCII text — one more reason SQLite is development-only. The rewrite skips
+string literals and quoted identifiers, so a stored value containing the word is
+left alone.
+
 ### Known gaps not yet addressed
 
 These still contain Postgres-only SQL and will fail at runtime on SQLite:
 
 | Construct | Extent | Note |
 |---|---|---|
-| `ILIKE` | 17 files | SQLite `LIKE` is already case-insensitive for ASCII, so this is a mechanical swap |
 | `::int`, `::float`, `::bigint`, `::numeric`, `::text`, `::jsonb` casts | ~109 occurrences | mostly in analytics and reporting aggregates |
 | `date_trunc` bucketing | reporting compiler, A/R analytics | marked `dialect:postgres-only`; needs a `strftime` equivalent |
 | `pg_stat_activity`, `pg_blocking_pids` | database session diagnostics | gated on `CapSessionDiagnostic`, returns 501 on SQLite |

services/tms/.gitignore

@@ -4,4 +4,7 @@ build
 .idea
 config/config.yaml/cli
 config/*
-*.db
+*.db
+*.db-shm
+*.db-wal
+*.db-journal

services/tms/internal/infrastructure/postgres/connection.go

@@ -205,9 +205,9 @@ func (c *Connection) openDB(
 	dsn string,
 ) (*sql.DB, schema.Dialect, error) {
 	if dialect.IsSQLite() {
-		sqldb, err := sql.Open(sqliteDriverName, dsn)
+		sqldb, err := openSQLiteDB(dsn)
 		if err != nil {
-			return nil, nil, fmt.Errorf("failed to open sqlite database: %w", err)
+			return nil, nil, err
 		}
 
 		return sqldb, sqlitedialect.New(), nil

services/tms/internal/infrastructure/postgres/sqlitedriver.go

@@ -0,0 +1,215 @@
+package postgres
+
+import (
+	"context"
+	"database/sql"
+	"database/sql/driver"
+	"fmt"
+	"strings"
+	"sync"
+)
+
+// SQLite has no ILIKE operator, and unlike a missing function it cannot be
+// polyfilled: ILIKE is a parser keyword, so SQLite rejects the statement before
+// any user-defined function could run.
+//
+// The operator appears in roughly fifty places, but almost none of them can be
+// fixed at the call site. buncolgen and querybuilder precompute their SQL
+// fragments into package-level values at init, long before configuration is
+// read, and most of buncolgen is generated. Rewriting the statement as it
+// reaches the driver is therefore the only single point that covers all of them.
+//
+// The substitution is sound because SQLite's LIKE is already case-insensitive
+// for ASCII, which is what ILIKE is used for here. It is not equivalent for
+// non-ASCII text, and that is one more reason SQLite is development-only.
+const sqliteRewriteDriverName = "sqlite-trenova"
+
+var registerSQLiteRewriteDriver sync.Once
+
+// rewriteILike replaces the ILIKE operator with LIKE outside string literals and
+// quoted identifiers, so a value or column name containing the word is untouched.
+func rewriteILike(query string) string {
+	if !containsFold(query, "ilike") {
+		return query
+	}
+
+	var (
+		out      strings.Builder
+		inSingle bool
+		inDouble bool
+		i        int
+	)
+
+	out.Grow(len(query))
+
+	for i < len(query) {
+		ch := query[i]
+
+		switch {
+		case inSingle:
+			if ch == '\'' {
+				inSingle = false
+			}
+		case inDouble:
+			if ch == '"' {
+				inDouble = false
+			}
+		case ch == '\'':
+			inSingle = true
+		case ch == '"':
+			inDouble = true
+		case (ch == 'i' || ch == 'I') && isILikeAt(query, i):
+			out.WriteString("LIKE")
+			i += len("ILIKE")
+			continue
+		}
+
+		out.WriteByte(ch)
+		i++
+	}
+
+	return out.String()
+}
+
+func isILikeAt(query string, i int) bool {
+	const keyword = "ilike"
+
+	if i+len(keyword) > len(query) {
+		return false
+	}
+
+	if !strings.EqualFold(query[i:i+len(keyword)], keyword) {
+		return false
+	}
+
+	if i > 0 && isIdentifierByte(query[i-1]) {
+		return false
+	}
+
+	end := i + len(keyword)
+
+	return end == len(query) || !isIdentifierByte(query[end])
+}
+
+func isIdentifierByte(b byte) bool {
+	return b == '_' ||
+		(b >= 'a' && b <= 'z') ||
+		(b >= 'A' && b <= 'Z') ||
+		(b >= '0' && b <= '9')
+}
+
+func containsFold(haystack, needle string) bool {
+	return strings.Contains(strings.ToLower(haystack), needle)
+}
+
+// openSQLiteDB returns a database handle whose statements pass through
+// rewriteILike on the way to modernc.org/sqlite.
+func openSQLiteDB(dsn string) (*sql.DB, error) {
+	base, err := sql.Open(sqliteDriverName, dsn)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open sqlite database: %w", err)
+	}
+
+	inner := base.Driver()
+	if closeErr := base.Close(); closeErr != nil {
+		return nil, fmt.Errorf("failed to close probe sqlite handle: %w", closeErr)
+	}
+
+	registerSQLiteRewriteDriver.Do(func() {
+		sql.Register(sqliteRewriteDriverName, &rewriteDriver{inner: inner})
+	})
+
+	return sql.OpenDB(&rewriteConnector{dsn: dsn, inner: inner}), nil
+}
+
+type rewriteDriver struct {
+	inner driver.Driver
+}
+
+func (d *rewriteDriver) Open(name string) (driver.Conn, error) {
+	conn, err := d.inner.Open(name)
+	if err != nil {
+		return nil, err
+	}
+
+	return &rewriteConn{inner: conn}, nil
+}
+
+type rewriteConnector struct {
+	dsn   string
+	inner driver.Driver
+}
+
+func (c *rewriteConnector) Connect(_ context.Context) (driver.Conn, error) {
+	conn, err := c.inner.Open(c.dsn)
+	if err != nil {
+		return nil, err
+	}
+
+	return &rewriteConn{inner: conn}, nil
+}
+
+func (c *rewriteConnector) Driver() driver.Driver {
+	return &rewriteDriver{inner: c.inner}
+}
+
+// rewriteConn deliberately implements only the prepare path. database/sql falls
+// back to Prepare when a connection does not advertise QueryerContext or
+// ExecerContext, which keeps every statement going through the rewrite rather
+// than slipping past it on a fast path.
+type rewriteConn struct {
+	inner driver.Conn
+}
+
+func (c *rewriteConn) Prepare(query string) (driver.Stmt, error) {
+	return c.inner.Prepare(rewriteILike(query))
+}
+
+func (c *rewriteConn) PrepareContext(
+	ctx context.Context,
+	query string,
+) (driver.Stmt, error) {
+	if preparer, ok := c.inner.(driver.ConnPrepareContext); ok {
+		return preparer.PrepareContext(ctx, rewriteILike(query))
+	}
+
+	return c.inner.Prepare(rewriteILike(query))
+}
+
+func (c *rewriteConn) Close() error { return c.inner.Close() }
+
+func (c *rewriteConn) Begin() (driver.Tx, error) { //nolint:staticcheck // required by driver.Conn
+	return c.inner.Begin() //nolint:staticcheck // delegating to the wrapped driver
+}
+
+func (c *rewriteConn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
+	if beginner, ok := c.inner.(driver.ConnBeginTx); ok {
+		return beginner.BeginTx(ctx, opts)
+	}
+
+	return c.inner.Begin() //nolint:staticcheck // fallback for drivers without BeginTx
+}
+
+func (c *rewriteConn) Ping(ctx context.Context) error {
+	if pinger, ok := c.inner.(driver.Pinger); ok {
+		return pinger.Ping(ctx)
+	}
+
+	return nil
+}
+
+func (c *rewriteConn) ResetSession(ctx context.Context) error {
+	if resetter, ok := c.inner.(driver.SessionResetter); ok {
+		return resetter.ResetSession(ctx)
+	}
+
+	return nil
+}
+
+func (c *rewriteConn) IsValid() bool {
+	if validator, ok := c.inner.(driver.Validator); ok {
+		return validator.IsValid()
+	}
+
+	return true
+}

services/tms/internal/infrastructure/postgres/sqlitedriver_test.go

@@ -0,0 +1,120 @@
+package postgres
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRewriteILike(t *testing.T) {
+	tests := []struct {
+		name  string
+		query string
+		want  string
+	}{
+		{
+			name:  "leaves a query without the operator alone",
+			query: `SELECT * FROM t WHERE a = ?`,
+			want:  `SELECT * FROM t WHERE a = ?`,
+		},
+		{
+			name:  "rewrites the operator",
+			query: `SELECT * FROM t WHERE name ILIKE ?`,
+			want:  `SELECT * FROM t WHERE name LIKE ?`,
+		},
+		{
+			name:  "rewrites regardless of case",
+			query: `SELECT * FROM t WHERE name iLiKe ?`,
+			want:  `SELECT * FROM t WHERE name LIKE ?`,
+		},
+		{
+			name:  "rewrites NOT ILIKE",
+			query: `SELECT * FROM t WHERE name NOT ILIKE ?`,
+			want:  `SELECT * FROM t WHERE name NOT LIKE ?`,
+		},
+		{
+			name:  "rewrites every occurrence",
+			query: `SELECT * FROM t WHERE a ILIKE ? OR b ILIKE ?`,
+			want:  `SELECT * FROM t WHERE a LIKE ? OR b LIKE ?`,
+		},
+		{
+			name:  "leaves string literals untouched",
+			query: `SELECT * FROM t WHERE note = ' ILIKE ' AND name ILIKE ?`,
+			want:  `SELECT * FROM t WHERE note = ' ILIKE ' AND name LIKE ?`,
+		},
+		{
+			name:  "leaves quoted identifiers untouched",
+			query: `SELECT "ilike" FROM t WHERE name ILIKE ?`,
+			want:  `SELECT "ilike" FROM t WHERE name LIKE ?`,
+		},
+		{
+			name:  "does not touch a column whose name merely contains the word",
+			query: `SELECT * FROM t WHERE ilike_count > ? AND unilike > ?`,
+			want:  `SELECT * FROM t WHERE ilike_count > ? AND unilike > ?`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, rewriteILike(tt.query))
+		})
+	}
+}
+
+func TestSQLiteDriverExecutesILike(t *testing.T) {
+	ctx := t.Context()
+	path := filepath.Join(t.TempDir(), "ilike.db")
+
+	db, err := openSQLiteDB("file:" + path)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = db.Close() })
+
+	_, err = db.ExecContext(ctx, `CREATE TABLE people (name TEXT)`)
+	require.NoError(t, err)
+
+	_, err = db.ExecContext(ctx, `INSERT INTO people (name) VALUES ('Alice'), ('bob')`)
+	require.NoError(t, err)
+
+	var name string
+	require.NoError(
+		t,
+		db.QueryRowContext(ctx, `SELECT name FROM people WHERE name ILIKE ?`, "alice").Scan(&name),
+		"ILIKE must survive the rewrite and execute on SQLite",
+	)
+	assert.Equal(t, "Alice", name, "ILIKE must stay case-insensitive after the rewrite")
+
+	require.NoError(
+		t,
+		db.QueryRowContext(ctx, `SELECT name FROM people WHERE name ILIKE ?`, "BOB").Scan(&name),
+	)
+	assert.Equal(t, "bob", name)
+}
+
+func TestSQLiteDriverPreservesLiteralContainingILike(t *testing.T) {
+	ctx := t.Context()
+	path := filepath.Join(t.TempDir(), "literal.db")
+
+	db, err := openSQLiteDB("file:" + path)
+	require.NoError(t, err)
+	t.Cleanup(func() { _ = db.Close() })
+
+	_, err = db.ExecContext(ctx, `CREATE TABLE notes (body TEXT)`)
+	require.NoError(t, err)
+
+	_, err = db.ExecContext(ctx, `INSERT INTO notes (body) VALUES ('uses ILIKE here')`)
+	require.NoError(t, err)
+
+	var body string
+	require.NoError(
+		t,
+		db.QueryRowContext(ctx, `SELECT body FROM notes WHERE body ILIKE ?`, "%ilike%").Scan(&body),
+	)
+	assert.Equal(
+		t,
+		"uses ILIKE here",
+		body,
+		"a stored value containing ILIKE must not be rewritten",
+	)
+}