validateOnConflictTypes

Author: nikolayk812

internal/compiler/analyze.go

@@ -1,10 +1,12 @@
 package compiler
 
 import (
+	"fmt"
 	"sort"
 
 	analyzer "github.com/sqlc-dev/sqlc/internal/analysis"
 	"github.com/sqlc-dev/sqlc/internal/config"
+	"github.com/sqlc-dev/sqlc/internal/engine/postgresql"
 	"github.com/sqlc-dev/sqlc/internal/source"
 	"github.com/sqlc-dev/sqlc/internal/sql/ast"
 	"github.com/sqlc-dev/sqlc/internal/sql/named"
@@ -143,6 +145,7 @@ func (c *Compiler) _analyzeQuery(raw *ast.RawStmt, query string, failfast bool)
 	raw, namedParams, edits := rewrite.NamedParameters(c.conf.Engine, raw, numbers, dollar)
 
 	var table *ast.TableName
+	var insertStmt *ast.InsertStmt
 	switch n := raw.Stmt.(type) {
 	case *ast.InsertStmt:
 		if err := check(validate.InsertStmt(n)); err != nil {
@@ -156,6 +159,7 @@ func (c *Compiler) _analyzeQuery(raw *ast.RawStmt, query string, failfast bool)
 		if err := check(c.validateOnConflictColumns(n)); err != nil {
 			return nil, err
 		}
+		insertStmt = n
 	}
 
 	if err := check(validate.FuncCall(c.catalog, c.combo, raw)); err != nil {
@@ -189,6 +193,11 @@ func (c *Compiler) _analyzeQuery(raw *ast.RawStmt, query string, failfast bool)
 	if err := check(err); err != nil {
 		return nil, err
 	}
+	if c.conf.Engine == config.EnginePostgreSQL {
+		if err := check(c.validateOnConflictTypes(insertStmt, params)); err != nil {
+			return nil, err
+		}
+	}
 	cols, err := c.outputColumns(qc, raw.Stmt)
 	if err := check(err); err != nil {
 		return nil, err
@@ -281,6 +290,79 @@ func (c *Compiler) validateOnConflictColumns(n *ast.InsertStmt) error {
 	return nil
 }
 
+// validateOnConflictTypes checks that $N params used in DO UPDATE SET assignments
+// are type-compatible with the target column, based on the type already resolved
+// for that param from the INSERT columns.
+func (c *Compiler) validateOnConflictTypes(n *ast.InsertStmt, params []Parameter) error {
+	if n == nil || n.OnConflictClause == nil || n.OnConflictClause.Action != ast.OnConflictActionUpdate {
+		return nil
+	}
+	fqn, err := ParseTableName(n.Relation)
+	if err != nil {
+		return err
+	}
+	table, err := c.catalog.GetTable(fqn)
+	if err != nil {
+		return err
+	}
+
+	// Build param number → resolved DataType string from already-resolved params.
+	// Skips params with "any" type (unresolved).
+	paramDataTypes := make(map[int]string, len(params))
+	for i := range params {
+		if params[i].Column != nil && params[i].Column.DataType != "any" {
+			paramDataTypes[params[i].Number] = params[i].Column.DataType
+		}
+	}
+
+	// Build column name → DataType string using the same dataType() function
+	// used by resolveCatalogRefs, so formats are comparable.
+	colDataTypes := make(map[string]string, len(table.Columns))
+	for _, col := range table.Columns {
+		colDataTypes[col.Name] = dataType(&col.Type)
+	}
+
+	for _, item := range n.OnConflictClause.TargetList.Items {
+		target, ok := item.(*ast.ResTarget)
+		if !ok || target.Name == nil {
+			continue
+		}
+		colDT, ok := colDataTypes[*target.Name]
+		if !ok {
+			continue
+		}
+		switch val := target.Val.(type) {
+		case *ast.ParamRef:
+			paramDT, ok := paramDataTypes[val.Number]
+			if !ok {
+				continue
+			}
+			if postgresql.TypeFamily(paramDT) != postgresql.TypeFamily(colDT) {
+				return &sqlerr.Error{
+					Message:  fmt.Sprintf("parameter $%d has type %q but column %q has type %q", val.Number, paramDT, *target.Name, colDT),
+					Location: val.Location,
+				}
+			}
+		case *ast.ColumnRef:
+			excludedCol, ok := excludedColumn(val)
+			if !ok {
+				continue
+			}
+			excludedDT, ok := colDataTypes[excludedCol]
+			if !ok {
+				continue
+			}
+			if postgresql.TypeFamily(excludedDT) != postgresql.TypeFamily(colDT) {
+				return &sqlerr.Error{
+					Message:  fmt.Sprintf("EXCLUDED.%s has type %q but column %q has type %q", excludedCol, excludedDT, *target.Name, colDT),
+					Location: val.Location,
+				}
+			}
+		}
+	}
+	return nil
+}
+
 // excludedColumn returns the column name if the ColumnRef is an EXCLUDED.col
 // reference, and ok=true. Returns "", false otherwise.
 func excludedColumn(ref *ast.ColumnRef) (string, bool) {

internal/endtoend/testdata/update_set_on_conflict/postgresql/pgx/query.sql

@@ -12,3 +12,14 @@ DO UPDATE SET name = 1111;
 INSERT INTO servers(code, name) VALUES ($1, $2)
 ON CONFLICT (code)
 DO UPDATE SET name = EXCLUDED.name_typo;
+
+-- name: UpsertServerSetParamTypeMismatch :exec
+INSERT INTO servers(code, name) VALUES ($1, $2)
+ON CONFLICT (code)
+DO UPDATE SET count = $2;
+
+-- name: UpsertServerExcludedTypeMismatch :exec
+INSERT INTO servers(code, name, count) VALUES ($1, $2, $3)
+ON CONFLICT (code)
+DO UPDATE SET count = EXCLUDED.code;
+

internal/endtoend/testdata/update_set_on_conflict/postgresql/pgx/schema.sql

@@ -1,4 +1,5 @@
 CREATE TABLE servers (
-  code varchar   PRIMARY KEY,
-  name text      NOT NULL
-);
+  code    varchar PRIMARY KEY,
+  name    text    NOT NULL,
+  count   integer NOT NULL DEFAULT 0
+);

internal/endtoend/testdata/update_set_on_conflict/postgresql/pgx/stderr.txt

@@ -2,3 +2,5 @@
 query.sql:4:15: column "name_typo" of relation "servers" does not exist
 query.sql:8:13: column "code_typo" of relation "servers" does not exist
 query.sql:14:22: column "name_typo" of relation "servers" does not exist
+query.sql:19:23: parameter $2 has type "text" but column "count" has type "pg_catalog.int4"
+query.sql:24:23: EXCLUDED.code has type "pg_catalog.varchar" but column "count" has type "pg_catalog.int4"

internal/engine/postgresql/utils.go

@@ -39,6 +39,75 @@ func IsNamedParamSign(node *nodes.Node) bool {
 	return ok && joinNodes(expr.AExpr.Name, ".") == "@"
 }
 
+// TypeFamily maps a PostgreSQL DataType string to a canonical type family name,
+// grouping compatible type aliases together. This is used for type compatibility
+// checks rather than exact string equality, because PostgreSQL considers many
+// type aliases assignment-compatible (e.g. text and varchar are both string types).
+//
+// The groupings are derived from postgresType() in
+// internal/codegen/golang/postgresql_type.go, which maps these aliases to the
+// same Go type. We cannot call postgresType() directly for type compatibility
+// checking because it requires *plugin.GenerateRequest — a protobuf codegen
+// struct constructed after compilation — and driver-specific opts.Options.
+func TypeFamily(dt string) string {
+	switch dt {
+	case "serial", "serial4", "pg_catalog.serial4",
+		"integer", "int", "int4", "pg_catalog.int4":
+		return "int32"
+	case "bigserial", "serial8", "pg_catalog.serial8",
+		"bigint", "int8", "pg_catalog.int8",
+		"interval", "pg_catalog.interval":
+		return "int64"
+	case "smallserial", "serial2", "pg_catalog.serial2",
+		"smallint", "int2", "pg_catalog.int2":
+		return "int16"
+	case "float", "double precision", "float8", "pg_catalog.float8":
+		return "float64"
+	case "real", "float4", "pg_catalog.float4":
+		return "float32"
+	case "numeric", "pg_catalog.numeric", "money":
+		return "numeric"
+	case "boolean", "bool", "pg_catalog.bool":
+		return "bool"
+	case "json", "pg_catalog.json":
+		return "json"
+	case "jsonb", "pg_catalog.jsonb":
+		return "jsonb"
+	case "bytea", "blob", "pg_catalog.bytea":
+		return "bytes"
+	case "date":
+		return "date"
+	case "pg_catalog.time":
+		return "time"
+	case "pg_catalog.timetz":
+		return "timetz"
+	case "pg_catalog.timestamp", "timestamp":
+		return "timestamp"
+	case "pg_catalog.timestamptz", "timestamptz":
+		return "timestamptz"
+	case "text", "pg_catalog.varchar", "pg_catalog.bpchar",
+		"string", "citext", "name",
+		"ltree", "lquery", "ltxtquery":
+		return "text"
+	case "uuid":
+		return "uuid"
+	case "inet":
+		return "inet"
+	case "cidr":
+		return "cidr"
+	case "macaddr", "macaddr8":
+		return "macaddr"
+	case "bit", "varbit", "pg_catalog.bit", "pg_catalog.varbit":
+		return "bits"
+	case "hstore":
+		return "hstore"
+	case "vector":
+		return "vector"
+	default:
+		return dt
+	}
+}
+
 func makeByte(s string) byte {
 	var b byte
 	if s == "" {