compiler: Support calling functions with defaults (#635)

Fix a number of bugs when resolving function calls.
Switch to using functions generated from a default PostgreSQL instance.
Add a new test case ripped from the PostgreSQL docs.

Author: kyleconroy

internal/codegen/golang/postgresql_type.go

@@ -13,19 +13,19 @@ func postgresType(r *compiler.Result, col *compiler.Column, settings config.Comb
 	notNull := col.NotNull || col.IsArray
 
 	switch columnType {
-	case "serial", "pg_catalog.serial4":
+	case "serial", "serial4", "pg_catalog.serial4":
 		if notNull {
 			return "int32"
 		}
 		return "sql.NullInt32"
 
-	case "bigserial", "pg_catalog.serial8":
+	case "bigserial", "serial8", "pg_catalog.serial8":
 		if notNull {
 			return "int64"
 		}
 		return "sql.NullInt64"
 
-	case "smallserial", "pg_catalog.serial2":
+	case "smallserial", "serial2", "pg_catalog.serial2":
 		return "int16"
 
 	case "integer", "int", "int4", "pg_catalog.int4":
@@ -43,19 +43,19 @@ func postgresType(r *compiler.Result, col *compiler.Column, settings config.Comb
 	case "smallint", "int2", "pg_catalog.int2":
 		return "int16"
 
-	case "float", "double precision", "pg_catalog.float8":
+	case "float", "double precision", "float8", "pg_catalog.float8":
 		if notNull {
 			return "float64"
 		}
 		return "sql.NullFloat64"
 
-	case "real", "pg_catalog.float4":
+	case "real", "float4", "pg_catalog.float4":
 		if notNull {
 			return "float32"
 		}
 		return "sql.NullFloat64" // TODO: Change to sql.NullFloat32 after updating the go.mod file
 
-	case "pg_catalog.numeric", "money":
+	case "numeric", "pg_catalog.numeric", "money":
 		// Since the Go standard library does not have a decimal type, lib/pq
 		// returns numerics as strings.
 		//
@@ -121,7 +121,7 @@ func postgresType(r *compiler.Result, col *compiler.Column, settings config.Comb
 		}
 		return "sql.NullString"
 
-	case "pg_catalog.interval":
+	case "interval", "pg_catalog.interval":
 		if notNull {
 			return "int64"
 		}

internal/compiler/output_columns.go

@@ -149,7 +149,7 @@ func outputColumns(qc *QueryCatalog, node ast.Node) ([]*Column, error) {
 			if res.Name != nil {
 				name = *res.Name
 			}
-			fun, err := qc.catalog.GetFuncN(rel, len(n.Args.Items))
+			fun, err := qc.catalog.ResolveFuncCall(n)
 			if err == nil {
 				cols = append(cols, &Column{Name: name, DataType: dataType(fun.ReturnType), NotNull: true})
 			} else {

internal/compiler/resolve.go

@@ -170,24 +170,25 @@ func resolveCatalogRefs(c *catalog.Catalog, rvs []*pg.RangeVar, args []paramRef,
 			}
 
 		case *ast.FuncCall:
-			fun, err := c.GetFuncN(n.Func, len(n.Args.Items))
+			fun, err := c.ResolveFuncCall(n)
 			if err != nil {
+				// Synthesize a function on the fly to avoid returning with an error
+				// for an unknown Postgres function (e.g. defined in an extension)
 				var args []*catalog.Argument
 				for range n.Args.Items {
 					args = append(args, &catalog.Argument{
 						Type: &ast.TypeName{Name: "any"},
 					})
 				}
-				// Synthesize a function on the fly to avoid returning with an error
-				// for an unknown Postgres function (e.g. defined in an extension)
-				fun = catalog.Function{
+				fun = &catalog.Function{
 					Name:       n.Func.Name,
 					Args:       args,
 					ReturnType: &ast.TypeName{Name: "any"},
 				}
 			}
 			for i, item := range n.Args.Items {
-				defaultName := fun.Name
+				funcName := fun.Name
+				var argName string
 				switch inode := item.(type) {
 				case *pg.ParamRef:
 					if inode.Number != ref.ref.Number {
@@ -210,11 +211,15 @@ func resolveCatalogRefs(c *catalog.Catalog, rvs []*pg.RangeVar, args []paramRef,
 						continue
 					}
 					if inode.Name != nil {
-						defaultName = *inode.Name
+						argName = *inode.Name
 					}
 				}
 
 				if fun.Args == nil {
+					defaultName := funcName
+					if argName != "" {
+						defaultName = argName
+					}
 					a = append(a, Parameter{
 						Number: ref.ref.Number,
 						Column: &Column{
@@ -225,19 +230,31 @@ func resolveCatalogRefs(c *catalog.Catalog, rvs []*pg.RangeVar, args []paramRef,
 					continue
 				}
 
-				if i >= len(fun.Args) {
-					return nil, fmt.Errorf("incorrect number of arguments to %s", fun.Name)
+				var paramName string
+				var paramType *ast.TypeName
+				if argName == "" {
+					paramName = fun.Args[i].Name
+					paramType = fun.Args[i].Type
+				} else {
+					paramName = argName
+					for _, arg := range fun.Args {
+						if arg.Name == argName {
+							paramType = arg.Type
+						}
+					}
+					if paramType == nil {
+						panic(fmt.Sprintf("named argument %s has no type", paramName))
+					}
 				}
-				arg := fun.Args[i]
-				name := arg.Name
-				if name == "" {
-					name = defaultName
+				if paramName == "" {
+					paramName = funcName
 				}
+
 				a = append(a, Parameter{
 					Number: ref.ref.Number,
 					Column: &Column{
-						Name:     parameterName(ref.ref.Number, name),
-						DataType: dataType(arg.Type),
+						Name:     parameterName(ref.ref.Number, paramName),
+						DataType: dataType(paramType),
 						NotNull:  true,
 					},
 				})

internal/endtoend/testdata/func_args/go/query.sql.go

@@ -0,0 +1,29 @@
+-- https://www.postgresql.org/docs/current/sql-syntax-calling-funcs.html
+CREATE FUNCTION concat_lower_or_upper(a text, b text, uppercase boolean DEFAULT false)
+RETURNS text
+AS
+$$
+ SELECT CASE
+        WHEN $3 THEN UPPER($1 || ' ' || $2)
+        ELSE LOWER($1 || ' ' || $2)
+        END;
+$$
+LANGUAGE SQL IMMUTABLE STRICT;
+
+-- name: PositionalNotation :one
+SELECT concat_lower_or_upper('Hello', 'World', true);
+
+-- name: PositionalNoDefaault :one
+SELECT concat_lower_or_upper('Hello', 'World');
+
+-- name: NamedNotation :one
+SELECT concat_lower_or_upper(a => 'Hello', b => 'World');
+
+-- name: NamedAnyOrder :one
+SELECT concat_lower_or_upper(a => 'Hello', b => 'World', uppercase => true);
+
+-- name: NamedOtherOrder :one
+SELECT concat_lower_or_upper(a => 'Hello', uppercase => true, b => 'World');
+
+-- name: MixedNotation :one
+SELECT concat_lower_or_upper('Hello', 'World', uppercase => true);