fix(compiler): preserve nullability when casting JSON arrow expressions (#3792)

PostgreSQL's JSON accessor operators (-->, ->>, #>, #>>) return SQL
NULL when the requested key or path is missing. Wrapping such an
expression in a type cast does not make the result non-nullable.

Today sqlc emits a non-nullable Go `string` for queries like:

    SELECT id,
           (data ->> 'PhoneNumber')::text AS phone_number,
           (data ->> 'ContactName')::text AS contact_name
    FROM jobs;

which crashes any consumer scanning into pgtype.Text / *string / sql.NullString
when the key happens to be absent. Real Postgres returns NULL in that
case; the generated row should too.

Fix:

* internal/sql/lang/operator.go — new IsJSONNullableOperator(s)
  classifier covering ->, ->>, #>, #>>.
* internal/compiler/output_columns.go — in the TypeCast case, when the
  wrapped argument is an A_Expr whose operator IsJSONNullableOperator,
  set col.NotNull = false. Tight scope: only the immediate cast arg.
  All other cast paths (literal, column from NOT NULL source, etc.)
  are unchanged — confirmed via regression repros.

Tests:

* internal/sql/lang/operator_test.go — TestIsJSONNullableOperator
  positive + negative table-driven test.
* internal/endtoend/testdata/json_arrow_cast_3792/postgresql/pgx/v5/ —
  end-to-end fixture reproducing the issue under pgx/v5; golden files
  show pgtype.Text for the three ->>-derived columns.

Verified locally:

* Repro from the issue now generates pgtype.Text instead of string.
* ('foo')::text, (column_not_null)::text still emit string. NULL
  literal cast still emits pgtype.Text (existing behavior preserved).
* go test ./internal/sql/... ./internal/compiler/... ./internal/engine/...
  passes; gofmt -l clean on touched files; go vet clean.

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

Author: Nguyễn Phúc Lương

internal/compiler/output_columns.go

@@ -366,6 +366,18 @@ func (c *Compiler) outputColumns(qc *QueryCatalog, node ast.Node) ([]*Column, er
 					col.NotNull = false
 				}
 			}
+			// A type cast does not make its argument non-nullable. If the
+			// wrapped expression is itself nullable, the result of the cast
+			// is too. Today we cover the common case of JSON accessor
+			// operators (`->`, `->>`, `#>`, `#>>`) which return NULL when
+			// the requested key/path is missing — wrapping `(data ->> 'k')`
+			// in `::text` was previously emitting a non-nullable string.
+			// See issue #3792.
+			if argExpr, ok := n.Arg.(*ast.A_Expr); ok {
+				if lang.IsJSONNullableOperator(astutils.Join(argExpr.Name, "")) {
+					col.NotNull = false
+				}
+			}
 			cols = append(cols, col)
 
 		case *ast.SelectStmt:

internal/endtoend/testdata/json_arrow_cast_3792/postgresql/pgx/v5/go/db.go

@@ -0,0 +1,9 @@
+-- name: ListJobs :many
+-- A `data ->> 'key'` lookup can return SQL NULL when the key is missing.
+-- A surrounding `::text` cast must preserve that nullability instead of
+-- emitting a non-nullable Go string. See issue #3792.
+SELECT id,
+       (data ->> 'PhoneNumber')::text AS phone_number,
+       (data ->> 'ContactName')::text AS contact_name,
+       (data ->> 'State')::text       AS state
+FROM jobs;

internal/endtoend/testdata/json_arrow_cast_3792/postgresql/pgx/v5/go/models.go

@@ -0,0 +1,4 @@
+CREATE TABLE jobs (
+    id BIGSERIAL PRIMARY KEY,
+    data JSONB NOT NULL
+);

internal/endtoend/testdata/json_arrow_cast_3792/postgresql/pgx/v5/go/query.sql.go

@@ -0,0 +1,13 @@
+{
+  "version": "1",
+  "packages": [
+    {
+      "path": "go",
+      "engine": "postgresql",
+      "sql_package": "pgx/v5",
+      "name": "querytest",
+      "schema": "schema.sql",
+      "queries": "query.sql"
+    }
+  ]
+}

internal/endtoend/testdata/json_arrow_cast_3792/postgresql/pgx/v5/query.sql

@@ -41,3 +41,18 @@ func IsMathematicalOperator(s string) bool {
 	}
 	return true
 }
+
+// IsJSONNullableOperator reports whether op is a Postgres JSON / JSONB
+// accessor operator that returns SQL NULL when the requested key or path
+// is missing from the value. These are: -> (object/array element as jsonb),
+// ->> (object/array element as text), #> (path lookup as jsonb), and #>>
+// (path lookup as text). Wrapping such an expression in a type cast does
+// not make the result non-nullable — the key may still be absent at run
+// time. See issue #3792.
+func IsJSONNullableOperator(s string) bool {
+	switch s {
+	case "->", "->>", "#>", "#>>":
+		return true
+	}
+	return false
+}

internal/endtoend/testdata/json_arrow_cast_3792/postgresql/pgx/v5/schema.sql

@@ -0,0 +1,17 @@
+package lang
+
+import "testing"
+
+func TestIsJSONNullableOperator(t *testing.T) {
+	t.Parallel()
+	for _, op := range []string{"->", "->>", "#>", "#>>"} {
+		if !IsJSONNullableOperator(op) {
+			t.Errorf("expected %q to be classified as JSON-nullable", op)
+		}
+	}
+	for _, op := range []string{"", "+", "-", "=", "::", "@>", "<@", "->>>"} {
+		if IsJSONNullableOperator(op) {
+			t.Errorf("did not expect %q to be classified as JSON-nullable", op)
+		}
+	}
+}