Review remark: handle error correctly when looking for schema.

postgresql/resource_postgresql_schema.go

@@ -173,7 +173,8 @@ func createSchema(d *schema.ResourceData, c *Client, txn *sql.Tx) error {
 	err := txn.QueryRow(`SELECT TRUE FROM pg_catalog.pg_namespace WHERE nspname = $1`, schemaName).Scan(&foundSchema)
 
 	queries := []string{}
-	if err == sql.ErrNoRows {
+	switch {
+	case err == sql.ErrNoRows:
 		b := bytes.NewBufferString("CREATE SCHEMA ")
 		if c.featureSupported(featureSchemaCreateIfNotExist) {
 			if v := d.Get(schemaIfNotExists); v.(bool) {
@@ -187,7 +188,12 @@ func createSchema(d *schema.ResourceData, c *Client, txn *sql.Tx) error {
 			fmt.Fprint(b, " AUTHORIZATION ", pq.QuoteIdentifier(v.(string)))
 		}
 		queries = append(queries, b.String())
-	} else {
+
+	case err != nil:
+		return fmt.Errorf("Error looking for schema: %w", err)
+
+	default:
+		// The schema already exists, we just set the owner.
 		if err := setSchemaOwner(txn, d); err != nil {
 			return err
 		}

postgresql/resource_postgresql_schema_test.go

@@ -234,6 +234,39 @@ resource "postgresql_schema" "test_cascade" {
 	})
 }
 
+func TestAccPostgresqlSchema_AlreadyExists(t *testing.T) {
+	skipIfNotAcc(t)
+
+	dbSuffix, teardown := setupTestDatabase(t, true, true)
+	defer teardown()
+
+	dbName, roleName := getTestDBNames(dbSuffix)
+
+	// Test to create the schema 'public' that already exists
+	// to assert it does not fail.
+	var testAccPostgresqlSchemaConfig = fmt.Sprintf(`
+resource "postgresql_schema" "public" {
+  name = "public"
+  database = "%s"
+  owner = "%s"
+}
+`, dbName, roleName)
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckPostgresqlSchemaDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccPostgresqlSchemaConfig,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckPostgresqlSchemaExists("postgresql_schema.public", "public"),
+					testAccCheckSchemaOwner(dbName, "public", roleName),
+				),
+			},
+		},
+	})
+}
+
 func testAccCheckPostgresqlSchemaDestroy(s *terraform.State) error {
 	client := testAccProvider.Meta().(*Client)
 
@@ -339,6 +372,32 @@ func testAccCreateSchemaTable(database, schemaName string) resource.TestCheckFun
 	}
 }
 
+func testAccCheckSchemaOwner(database, schemaName, expectedOwner string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		client, err := testAccProvider.Meta().(*Client).config.NewClient(database)
+		if err != nil {
+			return fmt.Errorf("could not create client on database %s: %w", schemaName, err)
+		}
+		db := client.DB()
+
+		var owner string
+
+		query := "SELECT pg_catalog.pg_get_userbyid(n.nspowner)  FROM pg_catalog.pg_namespace n WHERE n.nspname=$1"
+		switch err := db.QueryRow(query, schemaName).Scan(&owner); {
+		case err == sql.ErrNoRows:
+			return fmt.Errorf("could not find schema %s while checking owner", schemaName)
+		case err != nil:
+			return fmt.Errorf("error reading owner of schema %s: %w", schemaName, err)
+		}
+
+		if owner != expectedOwner {
+			return fmt.Errorf("expected owner of schema %s to be %s; got %s", schemaName, expectedOwner, owner)
+		}
+
+		return nil
+	}
+}
+
 const testAccPostgresqlSchemaConfig = `
 resource "postgresql_role" "role_all_without_grant" {
   name = "role_all_without_grant"