core: migrate all catalog queries to sqlc-generated code

Sweep the remaining hand-written SQL against the sql_* catalog tables
onto the generated catalogdb layer, completing the conversion started in
the types.go/FindProcs slice. Namespace, dialect, type, class,
attribute, constraint, proc, operator, and cast queries now all run
through catalogdb.Queries.

Notable rewrites:
- FindOperators: the conditionally-appended type filters become a single
  static query using (@arg = 0 OR col = @arg) sentinels.
- Nullable OID columns round-trip through sql.NullInt64 (orZero maps
  NULL to the 0 sentinel the Go API uses).
- New typed catalog accessors back the cross-package call sites that
  previously reached into the raw handle: DropClass (ClickHouse DROP
  TABLE), ClassColumns (analyzer scope), and Namespaces /
  TablesInNamespace / ClassCodegenColumns (codegen catalog projection).

Only the schema bootstrap (db.Exec(ddl)) and the DB()/Close() handles
remain as raw database/sql; every catalog query is now sqlc-generated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XTGxNHW6v1S1YyC9FDSgrK

Author: kyleconroy

internal/cmd/shim.go

@@ -244,67 +244,41 @@ func codeGenRequest(r *compiler.Result, settings config.CombinedSettings) *plugi
 
 // pluginCatalogFromCore projects a core.Catalog (the xqlc SQLite-backed
 // catalog) into the plugin.Catalog that codegen consumes to emit models
-// and enums. It reads the namespace / class / attribute / type tables
-// directly. Projection is best-effort: an unexpected query error against
-// the in-memory catalog yields a partial catalog rather than aborting
-// generation.
+// and enums. It reads through the catalog's typed accessors, which are
+// backed by sqlc-generated queries. Projection is best-effort: an
+// unexpected error against the in-memory catalog yields a partial catalog
+// rather than aborting generation.
 func pluginCatalogFromCore(cc *core.Catalog) *plugin.Catalog {
-	db := cc.DB()
 	var schemas []*plugin.Schema
 
-	type row struct {
-		oid  int64
-		name string
+	namespaces, err := cc.Namespaces()
+	if err != nil {
+		return &plugin.Catalog{DefaultSchema: "public"}
 	}
-	readRows := func(query string, args ...any) []row {
-		rows, err := db.Query(query, args...)
+	for _, ns := range namespaces {
+		tables, err := cc.TablesInNamespace(ns.OID)
 		if err != nil {
-			return nil
-		}
-		defer rows.Close()
-		var out []row
-		for rows.Next() {
-			var r row
-			if err := rows.Scan(&r.oid, &r.name); err != nil {
-				return out
-			}
-			out = append(out, r)
+			continue
 		}
-		return out
-	}
-
-	for _, ns := range readRows(`SELECT oid, name FROM sql_namespace ORDER BY oid`) {
-		var tables []*plugin.Table
-		for _, cl := range readRows(
-			`SELECT oid, name FROM sql_class WHERE namespace_oid = ? AND kind = 'r' ORDER BY oid`, ns.oid,
-		) {
-			rel := &plugin.Identifier{Schema: ns.name, Name: cl.name}
-			var columns []*plugin.Column
-			crows, err := db.Query(
-				`SELECT a.name, t.name, a.not_null
-				 FROM sql_attribute a JOIN sql_type t ON t.oid = a.type_oid
-				 WHERE a.class_oid = ? ORDER BY a.num`, cl.oid,
-			)
+		var ptables []*plugin.Table
+		for _, cl := range tables {
+			rel := &plugin.Identifier{Schema: ns.Name, Name: cl.Name}
+			cols, err := cc.ClassCodegenColumns(cl.OID)
 			if err != nil {
 				continue
 			}
-			for crows.Next() {
-				var name, typeName string
-				var notNull int
-				if err := crows.Scan(&name, &typeName, &notNull); err != nil {
-					break
-				}
+			var columns []*plugin.Column
+			for _, col := range cols {
 				columns = append(columns, &plugin.Column{
-					Name:    name,
-					Type:    &plugin.Identifier{Name: typeName},
-					NotNull: notNull != 0,
+					Name:    col.Name,
+					Type:    &plugin.Identifier{Name: col.TypeName},
+					NotNull: col.NotNull,
 					Table:   rel,
 				})
 			}
-			crows.Close()
-			tables = append(tables, &plugin.Table{Rel: rel, Columns: columns})
+			ptables = append(ptables, &plugin.Table{Rel: rel, Columns: columns})
 		}
-		schemas = append(schemas, &plugin.Schema{Name: ns.name, Tables: tables})
+		schemas = append(schemas, &plugin.Schema{Name: ns.Name, Tables: ptables})
 	}
 
 	return &plugin.Catalog{

internal/core/analyzer/scope.go

@@ -102,30 +102,25 @@ func (a *analyzer) bindRangeVar(rv *ast.RangeVar) (scopeRel, error) {
 	return rel, nil
 }
 
-// classColumns reads the column layout of a relation directly from
-// sql_attribute. We can't go through TableColumns because that resolves
-// by name and doesn't return attribute OIDs.
+// classColumns reads the column layout of a relation by class OID. It
+// goes through the catalog's ClassColumns accessor (backed by a
+// sqlc-generated query) rather than TableColumns, because it needs the
+// attribute OIDs and resolves by OID rather than by name.
 func (a *analyzer) classColumns(classOID int64) ([]scopeCol, error) {
-	rows, err := a.cat.DB().Query(
-		`SELECT a.oid, a.name, a.type_oid, a.not_null
-		 FROM sql_attribute a WHERE a.class_oid = ? ORDER BY a.num`,
-		classOID,
-	)
+	cols, err := a.cat.ClassColumns(classOID)
 	if err != nil {
 		return nil, err
 	}
-	defer rows.Close()
-	var out []scopeCol
-	for rows.Next() {
-		var c scopeCol
-		var nn int
-		if err := rows.Scan(&c.attOID, &c.name, &c.typeOID, &nn); err != nil {
-			return nil, err
-		}
-		c.notNull = nn != 0
-		out = append(out, c)
+	out := make([]scopeCol, 0, len(cols))
+	for _, c := range cols {
+		out = append(out, scopeCol{
+			name:    c.Name,
+			attOID:  c.AttOID,
+			typeOID: c.TypeOID,
+			notNull: c.NotNull,
+		})
 	}
-	return out, rows.Err()
+	return out, nil
 }
 
 // resolveColumn locates a (relation, column) pair in the scope.