fix: human readable formatting for types

Author: qykr

internal/compiler/compile.go

@@ -24,6 +24,7 @@ type Parser interface {
 	Parse(io.Reader) ([]ast.Statement, error)
 	CommentSyntax() source.CommentSyntax
 	IsReservedKeyword(string) bool
+	TypeName(ns, name string) string
 }
 
 func (c *Compiler) parseCatalog(schemas []string) error {

internal/compiler/resolve.go

@@ -26,11 +26,21 @@ func hasConcreteParamType(col *Column) bool {
 	return col != nil && col.DataType != "" && col.DataType != "any"
 }
 
-func paramTypeString(col *Column) string {
-    if !hasConcreteParamType(col) {
-        return "any"
-    }
-    return col.DataType + strings.Repeat("[]", col.ArrayDims)
+func (comp *Compiler) paramTypeString(col *Column) string {
+	if !hasConcreteParamType(col) {
+		return "any"
+	}
+
+	arraySuffix := strings.Repeat("[]", col.ArrayDims)
+	if col.Type != nil && col.Type.Name != "" {
+		return comp.parser.TypeName(col.Type.Schema, col.Type.Name) + arraySuffix
+	}
+
+	if rel, err := ParseRelationString(col.DataType); err == nil && rel.Catalog == "" {
+		return comp.parser.TypeName(rel.Schema, rel.Name) + arraySuffix
+	}
+
+	return col.DataType + arraySuffix
 }
 
 func compatibleParamTypes(a, b *Column) bool {
@@ -81,10 +91,15 @@ func mergeResolvedParam(existing, incoming Parameter) Parameter {
 	return base
 }
 
-func incompatibleParamRefError(ref paramRef, existing, incoming Parameter) error {
+func (comp *Compiler) incompatibleParamRefError(ref paramRef, existing, incoming Parameter) error {
 	return &sqlerr.Error{
 		Code:     "42P08",
-		Message:  fmt.Sprintf("parameter $%d has incompatible types: %s, %s", ref.ref.Number, paramTypeString(existing.Column), paramTypeString(incoming.Column)),
+		Message:  fmt.Sprintf(
+			"parameter $%d has incompatible types: %s, %s",
+			ref.ref.Number,
+			comp.paramTypeString(existing.Column),
+			comp.paramTypeString(incoming.Column),
+		),
 		Location: ref.ref.Location,
 	}
 }
@@ -171,7 +186,7 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 	addParam := func(ref paramRef, p Parameter) error {
 		if idx, ok := seen[p.Number]; ok {
 			if !compatibleParamTypes(a[idx].Column, p.Column) {
-				return incompatibleParamRefError(ref, a[idx], p)
+				return comp.incompatibleParamRefError(ref, a[idx], p)
 			}
 			a[idx] = mergeResolvedParam(a[idx], p)
 			return nil
@@ -381,9 +396,10 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 					p, isNamed := params.FetchMerge(ref.ref.Number, defaultP)
 					var namePrefix string
 					if !isNamed {
-						if ref.ref == n.Left {
+						switch ref.ref {
+						case n.Left:
 							namePrefix = "from_"
-						} else if ref.ref == n.Right {
+						case n.Right:
 							namePrefix = "to_"
 						}
 					}

internal/compiler/resolve_test.go

@@ -0,0 +1,68 @@
+package compiler
+
+import (
+	"testing"
+
+	"github.com/sqlc-dev/sqlc/internal/engine/postgresql"
+	"github.com/sqlc-dev/sqlc/internal/engine/sqlite"
+	"github.com/sqlc-dev/sqlc/internal/sql/ast"
+	"github.com/sqlc-dev/sqlc/internal/sql/sqlerr"
+)
+
+func TestParamTypeString(t *testing.T) {
+	t.Parallel()
+
+	t.Run("postgresql type aliases", func(t *testing.T) {
+		t.Parallel()
+		comp := &Compiler{parser: postgresql.NewParser()}
+
+		got := comp.paramTypeString(&Column{DataType: "pg_catalog.int4", ArrayDims: 2})
+		if got != "integer[][]" {
+			t.Fatalf("expected integer[][], got %q", got)
+		}
+	})
+
+	t.Run("structured type metadata is preferred", func(t *testing.T) {
+		t.Parallel()
+		comp := &Compiler{parser: postgresql.NewParser()}
+
+		got := comp.paramTypeString(&Column{
+			DataType: "catalog.pg_catalog.int4",
+			Type:     &ast.TypeName{Schema: "pg_catalog", Name: "bpchar"},
+		})
+		if got != "character" {
+			t.Fatalf("expected character, got %q", got)
+		}
+	})
+
+	t.Run("sqlite keeps names unchanged", func(t *testing.T) {
+		t.Parallel()
+		comp := &Compiler{parser: sqlite.NewParser()}
+
+		got := comp.paramTypeString(&Column{DataType: "custom_type", ArrayDims: 1})
+		if got != "custom_type[]" {
+			t.Fatalf("expected custom_type[], got %q", got)
+		}
+	})
+}
+
+func TestIncompatibleParamRefErrorFormatsTypeNames(t *testing.T) {
+	t.Parallel()
+
+	comp := &Compiler{parser: postgresql.NewParser()}
+	err := comp.incompatibleParamRefError(paramRef{ref: &ast.ParamRef{Number: 1}}, Parameter{
+		Number: 1,
+		Column: &Column{DataType: "text"},
+	}, Parameter{
+		Number: 1,
+		Column: &Column{DataType: "pg_catalog.int4"},
+	})
+
+	sqlErr, ok := err.(*sqlerr.Error)
+	if !ok {
+		t.Fatalf("expected *sqlerr.Error, got %T", err)
+	}
+	if sqlErr.Message != "parameter $1 has incompatible types: text, integer" {
+		t.Fatalf("unexpected message: %q", sqlErr.Message)
+	}
+}

internal/endtoend/testdata/invalid_reused_param_type/postgresql/stderr.txt

@@ -1,2 +1,2 @@
 # package querytest
-query.sql:5:10: parameter $1 has incompatible types: text, integer
+query.sql:5:10: parameter $1 has incompatible types: text, integer