Function arg types support (#228)

Author: marvin-kolja

postgresql/helpers.go

@@ -275,12 +275,32 @@ func pgArrayToSet(arr pq.ByteaArray) *schema.Set {
 	return schema.NewSet(schema.HashString, s)
 }
 
+func quoteIdentifyIdent(ident string) string {
+	// When passing a function with arguments like "test(text, char)" this will correctly parse it to "test"(text, char).
+	// If we were to add quotes around the whole ident postgres would not be able to find the function.
+	// Usually specifying parameters of a function is not necessary, but postgres allows function overloading where it
+	// identifies the function by its parameters allowing the developer to have multiple functions with the same name.
+	// Information:
+	// https://en.wikipedia.org/wiki/Function_overloading
+	// https://stackoverflow.com/a/48640797
+
+	s := strings.Split(ident, "(")
+
+	functionArgTypes := ""
+
+	if len(s) > 1 {
+		functionArgTypes = "(" + s[1]
+	}
+
+	return fmt.Sprintf("%s%s", pq.QuoteIdentifier(s[0]), functionArgTypes)
+}
+
 func setToPgIdentList(schema string, idents *schema.Set) string {
 	quotedIdents := make([]string, idents.Len())
 	for i, ident := range idents.List() {
 		quotedIdents[i] = fmt.Sprintf(
 			"%s.%s",
-			pq.QuoteIdentifier(schema), pq.QuoteIdentifier(ident.(string)),
+			pq.QuoteIdentifier(schema), quoteIdentifyIdent(ident.(string)),
 		)
 	}
 	return strings.Join(quotedIdents, ",")

postgresql/resource_postgresql_grant_test.go

@@ -3,6 +3,7 @@ package postgresql
 import (
 	"fmt"
 	"regexp"
+	"strings"
 	"testing"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
@@ -884,6 +885,68 @@ resource postgresql_grant "test" {
 	}
 }
 
+func TestAccPostgresqlGrantFunctionWithArgs(t *testing.T) {
+	skipIfNotAcc(t)
+
+	config := getTestConfig(t)
+	dsn := config.connStr("postgres")
+
+	// Create a test role and a schema as public has too wide open privileges
+	dbExecute(t, dsn, fmt.Sprintf("CREATE ROLE test_role LOGIN PASSWORD '%s'", testRolePassword))
+	dbExecute(t, dsn, "CREATE SCHEMA test_schema")
+	dbExecute(t, dsn, "GRANT USAGE ON SCHEMA test_schema TO test_role")
+	dbExecute(t, dsn, "ALTER DEFAULT PRIVILEGES REVOKE ALL ON FUNCTIONS FROM PUBLIC")
+
+	// Create test function in this schema
+	dbExecute(t, dsn, `
+CREATE FUNCTION test_schema.test(arg1 text, arg2 character) RETURNS text
+	AS $$ select 'foo'::text $$
+    LANGUAGE SQL;
+`)
+	defer func() {
+		dbExecute(t, dsn, "DROP SCHEMA test_schema CASCADE")
+		dbExecute(t, dsn, "DROP ROLE test_role")
+	}()
+
+	// Test to grant directly to test_role and to public
+	// in both case test_case should have the right
+	for _, role := range []string{"test_role", "public"} {
+		t.Run(role, func(t *testing.T) {
+
+			tfConfig := fmt.Sprintf(`
+resource postgresql_grant "test" {
+  database    = "postgres"
+  role        = "%s"
+  schema      = "test_schema"
+  object_type = "function"
+  privileges  = ["EXECUTE"]
+  objects 	  = ["test(text, char)"]
+}
+	`, role)
+
+			resource.Test(t, resource.TestCase{
+				PreCheck: func() {
+					testAccPreCheck(t)
+					testCheckCompatibleVersion(t, featurePrivileges)
+				},
+				Providers: testAccProviders,
+				Steps: []resource.TestStep{
+					{
+						Config: tfConfig,
+						Check: resource.ComposeTestCheckFunc(
+							resource.TestCheckResourceAttr("postgresql_grant.test", "id", fmt.Sprintf("%s_postgres_test_schema_function_test(text, char)", role)),
+							resource.TestCheckResourceAttr("postgresql_grant.test", "privileges.#", "1"),
+							resource.TestCheckResourceAttr("postgresql_grant.test", "privileges.0", "EXECUTE"),
+							resource.TestCheckResourceAttr("postgresql_grant.test", "with_grant_option", "false"),
+							testCheckFunctionWithArgsExecutable(t, "test_role", "test_schema.test", []string{pq.QuoteLiteral("value 1"), pq.QuoteLiteral("value 2")}),
+						),
+					},
+				},
+			})
+		})
+	}
+}
+
 func TestAccPostgresqlGrantProcedure(t *testing.T) {
 	skipIfNotAcc(t)
 	testCheckCompatibleVersion(t, featureProcedure)
@@ -1288,6 +1351,18 @@ func testCheckFunctionExecutable(t *testing.T, role, function string) func(*terr
 	}
 }
 
+func testCheckFunctionWithArgsExecutable(t *testing.T, role, function string, args []string) func(*terraform.State) error {
+	return func(*terraform.State) error {
+		db := connectAsTestRole(t, role, "postgres")
+		defer db.Close()
+
+		if err := testHasGrantForQuery(db, fmt.Sprintf("SELECT %s(%s)", function, strings.Join(args, ", ")), true); err != nil {
+			return err
+		}
+		return nil
+	}
+}
+
 func testCheckProcedureExecutable(t *testing.T, role, procedure string) func(*terraform.State) error {
 	return func(*terraform.State) error {
 		db := connectAsTestRole(t, role, "postgres")