Simplified changes and removed sqlc.embed.jsonb directive.

Author: m-ali-akbay

docs/howto/embedding.md

@@ -60,50 +60,31 @@ type ScoreAndTestsRow struct {
 }
 ```
 
-#### Nested JSON objects and arrays
+#### JSON objects and arrays
 
-`sqlc.jsonb_build_object."Name"(key, value, key, value, ...)` builds a named
-Go struct from an inline JSON shape — a typed wrapper around Postgres's
-`jsonb_build_object`, so keys must be string literals. This is most useful
-for pulling a one-to-many relationship into a single query as a slice
-field, instead of running a separate query per parent row. It's **pgx/v5
-only**: `sqlc generate` fails with a clear error for any other
-`sql_package`.
-
-`"Name"` is required and must be a double-quoted identifier in that
-position, not an argument — Postgres parses this as a 3-part qualified
-function name (`catalog.schema.name`), and sqlc reads the struct name
-directly off of it.
-
-```sql
-CREATE TABLE authors (
-  id   bigserial PRIMARY KEY,
-  name text NOT NULL
-);
-
-CREATE TABLE books (
-  id        bigserial PRIMARY KEY,
-  author_id bigint NOT NULL REFERENCES authors (id),
-  title     text NOT NULL
-);
-```
+`sqlc.jsonb_build_object."Name"(key, value, ...)` returns a JSON-shaped
+result decoded straight into a named Go struct (or `[]struct` inside
+`ARRAY(...)`), useful for pulling a one-to-many relationship into a single
+query instead of one query per parent row. It's **pgx/v5 only** — `sqlc
+generate` fails with a clear error for any other `sql_package`. `"Name"` is
+required and is read off the 3-part qualified function name Postgres parses
+(`catalog.schema.name`), not an argument; keys must be string literals.
 
 ```sql
 -- name: GetAuthors :many
 SELECT
-  sqlc.embed(authors),
+  authors.id,
   ARRAY(
     SELECT sqlc.jsonb_build_object."Book"('id', books.id, 'title', books.title)
-    FROM books
-    WHERE books.author_id = authors.id
+    FROM books WHERE books.author_id = authors.id
   ) AS books
 FROM authors;
 ```
 
 ```go
 type GetAuthorsRow struct {
-	Author Author
-	Books  []Book
+	ID    int64
+	Books []Book
 }
 
 type Book struct {
@@ -112,82 +93,9 @@ type Book struct {
 }
 ```
 
-No custom `Scan`/`Value` methods, no wrapper type — `Books` is a plain
-`[]Book`; pgx v5 decodes the `jsonb[]` column into it directly. A lone
-`sqlc.jsonb_build_object."Name"(...)` (not wrapped in `ARRAY(...)`) works
-the same way and produces a plain struct field instead of a slice:
-
-```sql
--- name: GetAuthorSummary :one
-SELECT sqlc.jsonb_build_object."AuthorSummary"('name', name) AS summary FROM authors LIMIT 1;
-```
-
-```go
-type GetAuthorSummaryRow struct {
-	Summary AuthorSummary
-}
-```
-
-Two queries that use the same explicit name reuse the same Go type, as long
-as their shapes match (this works even mixing scalar and `ARRAY(...)` uses
-of the same name). A shape mismatch, or a name that collides with an
-existing model/enum type, fails generation with an error instead of
-emitting Go code that won't compile.
-
-##### Overriding generated names
-
-The struct name and individual field names can be overridden via the
-`rename` option:
-
-```json
-{
-  "rename": {
-    "Book": "BookSummary",
-    "Book.id": "BookID"
-  }
-}
-```
-
-`"Book"` renames the type; `"Book.id"` renames just the `id` field within
-it, without affecting other types that also have an `id` key. Use the plain
-key (`"id"`) instead to rename that field everywhere.
-
-##### Embedding a whole row as JSON
-
-Listing every column by hand is tedious when you just want the whole row.
-`sqlc.embed.jsonb(table)` builds a JSON object from all of a table's columns,
-the same way `sqlc.embed(table)` gives you the table's model — but as a
-single JSON value, so it can be nested inside `ARRAY(...)` to return a slice
-of rows from one query:
-
-```sql
--- name: GetAuthorsWithBooks :many
-SELECT
-  authors.id,
-  ARRAY(SELECT sqlc.embed.jsonb(books) FROM books WHERE books.author_id = authors.id) AS books
-FROM authors;
-```
-
-```go
-type GetAuthorsWithBooksRow struct {
-	ID    int64  `json:"id"`
-	Books []Book `json:"books"`
-}
-
-type Book struct {
-	ID       int64  `json:"id"`
-	AuthorID int64  `json:"author_id"`
-	Title    string `json:"title"`
-}
-```
-
-The generated struct is named from the result alias — singularized for the
-`ARRAY(...)` case (`AS books` → `Book`), or used as-is for a scalar
-`sqlc.embed.jsonb(table) AS author` (→ `Author`). Fields, types and JSON keys
-come from the table's columns, so the object always decodes cleanly. Under
-the hood the call is rewritten to `to_jsonb(table)`, which you'll see in
-`EXPLAIN` output and logs.
-
-Like `sqlc.jsonb_build_object`, this is pgx/v5 only, and the generated name
-must not collide with a model or another JSON type; use the `rename` option
-if it does.
+The call is rewritten to Postgres's `jsonb_build_object`, which you'll see in
+`EXPLAIN` output. Two queries that use the same name share one Go type when
+their shapes match; a shape mismatch, or a name that collides with a model or
+another JSON type, fails generation. Names and fields can be overridden with
+`rename`: `"Book"` renames the type, `"Book.id"` just the `id` field within
+it.

internal/codegen/golang/gen.go

@@ -213,7 +213,7 @@ func generate(req *plugin.GenerateRequest, options *opts.Options, enums []Enum,
 	}
 
 	if usesJSON(queries) && tctx.SQLDriver != opts.SQLDriverPGXV5 {
-		return nil, errors.New("sqlc.jsonb_build_object(...) and sqlc.embed.jsonb(...) are only supported by pgx/v5")
+		return nil, errors.New("sqlc.jsonb_build_object(...) is only supported by pgx/v5")
 	}
 
 	funcMap := template.FuncMap{

internal/compiler/json_columns.go

@@ -1,22 +1,22 @@
 package compiler
 
 import (
+	"errors"
 	"fmt"
 
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
-	"github.com/sqlc-dev/sqlc/internal/sql/astutils"
+	"github.com/sqlc-dev/sqlc/internal/sql/rewrite"
 )
 
 // outputJSONColumn types an sqlc.jsonb_build_object."Name"(key, value, ...)
 // call as a synthesized struct: Name is the call's own function name, fields
 // come from the key/value pairs. Keys must be string literals; values are
-// typed like any other SELECT target.
+// typed by jsonValueColumn.
 func (c *Compiler) outputJSONColumn(qc *QueryCatalog, tables []*Table, res *ast.ResTarget, call *ast.FuncCall) (*Column, error) {
 	var args []ast.Node
 	if call.Args != nil {
 		args = call.Args.Items
 	}
-
 	jsonName := call.Func.Name
 
 	if len(args)%2 != 0 {
@@ -29,16 +29,10 @@ func (c *Compiler) outputJSONColumn(qc *QueryCatalog, tables []*Table, res *ast.
 		if !ok {
 			return nil, fmt.Errorf("sqlc.jsonb_build_object.%q(...) argument %d must be a string literal key", jsonName, i+1)
 		}
-
-		valCols, err := c.outputColumn(qc, tables, &ast.ResTarget{Val: args[i+1]})
+		val, err := c.jsonValueColumn(qc, tables, args[i+1], key)
 		if err != nil {
 			return nil, err
 		}
-		if len(valCols) != 1 {
-			return nil, fmt.Errorf("sqlc.jsonb_build_object.%q(...) value for key %q must resolve to a single column", jsonName, key)
-		}
-
-		val := valCols[0]
 		val.Name = key
 		fields = append(fields, val)
 	}
@@ -47,67 +41,53 @@ func (c *Compiler) outputJSONColumn(qc *QueryCatalog, tables []*Table, res *ast.
 	if res.Name != nil {
 		name = *res.Name
 	}
-	return &Column{
-		Name:       name,
-		DataType:   "any",
-		NotNull:    true,
-		JSONFields: fields,
-		JSONName:   jsonName,
-	}, nil
+	return &Column{Name: name, DataType: "any", NotNull: true, JSONFields: fields, JSONName: jsonName}, nil
 }
 
-// outputEmbedJSONColumn types an sqlc.embed.jsonb(table) call as a struct
-// mirroring the table's columns, decoded from a single to_jsonb(table) value.
-// The name comes from the result alias; the array case leaves it empty for
-// the enclosing ARRAY_SUBLINK to fill from its own alias.
-func (c *Compiler) outputEmbedJSONColumn(qc *QueryCatalog, tables []*Table, res *ast.ResTarget, call *ast.FuncCall) (*Column, error) {
-	if call.Args == nil || len(call.Args.Items) != 1 {
-		return nil, fmt.Errorf("sqlc.embed.jsonb(...) takes a single table argument")
-	}
-	ref, ok := call.Args.Items[0].(*ast.ColumnRef)
-	if !ok {
-		return nil, fmt.Errorf("sqlc.embed.jsonb(...) argument must be a table reference")
-	}
-	target := astutils.Join(ref.Fields, ".")
-
-	var table *Table
-	for _, t := range tables {
-		if t.Rel.Name == target {
-			table = t
-			break
+// jsonValueColumn types a single sqlc.jsonb_build_object value: a column
+// reference, a nested JSON call, or an ARRAY(...) of one of those.
+func (c *Compiler) jsonValueColumn(qc *QueryCatalog, tables []*Table, node ast.Node, key string) (*Column, error) {
+	switch v := node.(type) {
+	case *ast.ColumnRef:
+		cols, err := outputColumnRefs(&ast.ResTarget{Val: v}, tables, v)
+		if err != nil {
+			return nil, err
+		}
+		if len(cols) != 1 {
+			return nil, fmt.Errorf("sqlc.jsonb_build_object value for key %q must resolve to a single column", key)
+		}
+		return cols[0], nil
+	case *ast.SubLink:
+		if v.SubLinkType == ast.ARRAY_SUBLINK {
+			return c.arraySubLinkColumn(qc, tables, v)
+		}
+	case *ast.FuncCall:
+		if rewrite.IsJSONCall(v) {
+			return c.outputJSONColumn(qc, tables, &ast.ResTarget{}, v)
 		}
 	}
-	if table == nil {
-		return nil, fmt.Errorf("sqlc.embed.jsonb(%s): table not found in the query's FROM clause", target)
-	}
+	return &Column{DataType: "any"}, nil
+}
 
-	var fields []*Column
-	for _, col := range table.Columns {
-		fields = append(fields, &Column{
-			Name:      col.Name,
-			DataType:  col.DataType,
-			NotNull:   col.NotNull,
-			Unsigned:  col.Unsigned,
-			IsArray:   col.IsArray,
-			ArrayDims: col.ArrayDims,
-			Length:    col.Length,
-			Type:      col.Type,
-		})
+// arraySubLinkColumn types an ARRAY(subquery) expression: the subquery must
+// yield exactly one column, which becomes the array element.
+func (c *Compiler) arraySubLinkColumn(qc *QueryCatalog, tables []*Table, sublink *ast.SubLink) (*Column, error) {
+	subcols, err := c.outputColumns(qc, sublink.Subselect)
+	if err != nil {
+		return nil, err
 	}
-
-	name := "json"
-	jsonName := ""
-	if res.Name != nil {
-		name = *res.Name
-		jsonName = *res.Name
+	if len(subcols) != 1 {
+		return nil, errors.New("ARRAY() subquery must return only one column")
+	}
+	first := subcols[0]
+	if first.IsArray {
+		first.ArrayDims++
+	} else {
+		first.IsArray = true
+		first.ArrayDims = 1
 	}
-	return &Column{
-		Name:       name,
-		DataType:   "any",
-		NotNull:    true,
-		JSONFields: fields,
-		JSONName:   jsonName,
-	}, nil
+	first.NotNull = true
+	return first, nil
 }
 
 func jsonStringLiteral(node ast.Node) (string, bool) {

internal/compiler/json_columns_test.go

@@ -153,49 +153,3 @@ func TestOutputColumnsJSON(t *testing.T) {
 		}
 	})
 }
-
-func TestOutputColumnsEmbedJSON(t *testing.T) {
-	c := newTestCompiler(t, testSchema)
-
-	t.Run("scalar mirrors the table's columns", func(t *testing.T) {
-		a := mustAnalyze(t, c, `SELECT sqlc.embed.jsonb(items) AS obj FROM items;`)
-		col := a.Columns[0]
-		if col.JSONName != "obj" {
-			t.Errorf("JSONName = %q, want %q", col.JSONName, "obj")
-		}
-		if col.IsArray {
-			t.Errorf("IsArray = true, want false")
-		}
-		if !col.NotNull {
-			t.Errorf("NotNull = false, want true")
-		}
-		if len(col.JSONFields) != 3 {
-			t.Fatalf("expected 3 JSONFields (id, x, y), got %d", len(col.JSONFields))
-		}
-		names := []string{col.JSONFields[0].Name, col.JSONFields[1].Name, col.JSONFields[2].Name}
-		if names[0] != "id" || names[1] != "x" || names[2] != "y" {
-			t.Errorf("field names = %v, want [id x y]", names)
-		}
-	})
-
-	t.Run("array singularizes the outer alias for the element name", func(t *testing.T) {
-		a := mustAnalyze(t, c, `SELECT ARRAY(SELECT sqlc.embed.jsonb(items) FROM items) AS objs;`)
-		col := a.Columns[0]
-		if !col.IsArray || col.ArrayDims != 1 {
-			t.Errorf("IsArray/ArrayDims = %v/%d, want true/1", col.IsArray, col.ArrayDims)
-		}
-		if col.JSONName != "obj" {
-			t.Errorf("JSONName = %q, want %q (singular of the alias)", col.JSONName, "obj")
-		}
-		if len(col.JSONFields) != 3 {
-			t.Fatalf("expected 3 JSONFields, got %d", len(col.JSONFields))
-		}
-	})
-
-	t.Run("unknown table", func(t *testing.T) {
-		err := analyzeErr(t, c, `SELECT sqlc.embed.jsonb(missing) AS obj FROM items;`)
-		if !strings.Contains(err.Error(), "table not found") {
-			t.Errorf("error = %v, want mention of table not found", err)
-		}
-	})
-}