feat: support Cloud SQL\'s new field connection_pool_config. (#13497) (#22583)

[upstream:db2dbb701f705e2936c76e9cff368038ca0385f6]

Signed-off-by: Modular Magician <[email protected]>

Author: modular-magician

.changelog/13497.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+sql: added `connection_pool_config` field.
+```

google/services/sql/resource_sql_database_instance.go

@@ -75,6 +75,11 @@ var (
 		"settings.0.backup_configuration.0.transaction_log_retention_days",
 	}
 
+	connectionPoolConfigKeys = []string{
+		"settings.0.connection_pool_config.0.connection_pooling_enabled",
+		"settings.0.connection_pool_config.0.flags",
+	}
+
 	ipConfigurationKeys = []string{
 		"settings.0.ip_configuration.0.authorized_networks",
 		"settings.0.ip_configuration.0.ipv4_enabled",
@@ -432,6 +437,28 @@ is set to true. Defaults to ZONAL.`,
 							DiffSuppressFunc: caseDiffDashSuppress,
 							Description:      `The type of supported data disk is tier dependent and can be PD_SSD or PD_HDD or HYPERDISK_BALANCED.`,
 						},
+						"connection_pool_config": {
+							Type:        schema.TypeSet,
+							Optional:    true,
+							Computed:    true,
+							Description: `The managed connection pool setting for a Cloud SQL instance.`,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"connection_pooling_enabled": {
+										Type:        schema.TypeBool,
+										Optional:    true,
+										Description: `Whether Managed Connection Pool is enabled for this instance.`,
+									},
+									"flags": {
+										Type:        schema.TypeSet,
+										Optional:    true,
+										Set:         schema.HashResource(sqlDatabaseFlagSchemaElem),
+										Elem:        sqlDatabaseFlagSchemaElem,
+										Description: `List of connection pool configuration flags`,
+									},
+								},
+							},
+						},
 						"ip_configuration": {
 							Type:     schema.TypeList,
 							Optional: true,
@@ -1409,6 +1436,7 @@ func expandSqlDatabaseInstanceSettings(configured []interface{}, databaseVersion
 		UserLabels:                tpgresource.ConvertStringMap(_settings["user_labels"].(map[string]interface{})),
 		BackupConfiguration:       expandBackupConfiguration(_settings["backup_configuration"].([]interface{})),
 		DatabaseFlags:             expandDatabaseFlags(_settings["database_flags"].(*schema.Set).List()),
+		ConnectionPoolConfig:      expandConnectionPoolConfig(_settings["connection_pool_config"].(*schema.Set).List()),
 		IpConfiguration:           expandIpConfiguration(_settings["ip_configuration"].([]interface{}), databaseVersion),
 		LocationPreference:        expandLocationPreference(_settings["location_preference"].([]interface{})),
 		MaintenanceWindow:         expandMaintenanceWindow(_settings["maintenance_window"].([]interface{})),
@@ -1558,6 +1586,35 @@ func expandPscConfig(configured []interface{}) *sqladmin.PscConfig {
 	return nil
 }
 
+func expandFlags(configured []interface{}) []*sqladmin.ConnectionPoolFlags {
+	connectionPoolFlags := make([]*sqladmin.ConnectionPoolFlags, 0, len(configured))
+	for _, _flag := range configured {
+		if _flag == nil {
+			continue
+		}
+		_entry := _flag.(map[string]interface{})
+
+		connectionPoolFlags = append(connectionPoolFlags, &sqladmin.ConnectionPoolFlags{
+			Name:  _entry["name"].(string),
+			Value: _entry["value"].(string),
+		})
+	}
+	return connectionPoolFlags
+}
+
+func expandConnectionPoolConfig(configured []interface{}) *sqladmin.ConnectionPoolConfig {
+	if len(configured) == 0 || configured[0] == nil {
+		return nil
+	}
+
+	_connectionPoolConfig := configured[0].(map[string]interface{})
+
+	return &sqladmin.ConnectionPoolConfig{
+		ConnectionPoolingEnabled: _connectionPoolConfig["connection_pooling_enabled"].(bool),
+		Flags:                    expandFlags(_connectionPoolConfig["flags"].(*schema.Set).List()),
+	}
+}
+
 func expandAuthorizedNetworks(configured []interface{}) []*sqladmin.AclEntry {
 	an := make([]*sqladmin.AclEntry, 0, len(configured))
 	for _, _acl := range configured {
@@ -2315,6 +2372,10 @@ func flattenSettings(settings *sqladmin.Settings, d *schema.ResourceData) []map[
 		data["database_flags"] = flattenDatabaseFlags(settings.DatabaseFlags)
 	}
 
+	if settings.ConnectionPoolConfig != nil {
+		data["connection_pool_config"] = flattenConnectionPoolConfig(settings.ConnectionPoolConfig)
+	}
+
 	if settings.IpConfiguration != nil {
 		data["ip_configuration"] = flattenIpConfiguration(settings.IpConfiguration, d)
 	}
@@ -2485,6 +2546,38 @@ func flattenReplicationCluster(replicationCluster *sqladmin.ReplicationCluster,
 	return []map[string]interface{}{data}
 }
 
+func flattenConnectionPoolFlags(connectionPoolFlags []*sqladmin.ConnectionPoolFlags) []interface{} {
+	if len(connectionPoolFlags) == 0 { // Handles nil or empty slice
+		return make([]interface{}, 0) // Explicitly return empty slice
+	}
+
+	mcpflags := make([]interface{}, len(connectionPoolFlags)) // Pre-allocate for efficiency
+	for i, mcpflag := range connectionPoolFlags {
+		data := map[string]interface{}{
+			"name":  mcpflag.Name,
+			"value": mcpflag.Value,
+		}
+		mcpflags[i] = data
+	}
+	return mcpflags
+}
+
+func flattenConnectionPoolConfig(connectionPoolConfig *sqladmin.ConnectionPoolConfig) []interface{} {
+	if connectionPoolConfig == nil {
+		return []interface{}{
+			map[string]interface{}{
+				"connection_pooling_enabled": false,
+				"flags":                      make([]interface{}, 0), // Default to empty flags
+			},
+		}
+	}
+	data := map[string]interface{}{
+		"connection_pooling_enabled": connectionPoolConfig.ConnectionPoolingEnabled,          // Corrected key
+		"flags":                      flattenConnectionPoolFlags(connectionPoolConfig.Flags), // Corrected key
+	}
+	return []interface{}{data}
+}
+
 func flattenIpConfiguration(ipConfiguration *sqladmin.IpConfiguration, d *schema.ResourceData) interface{} {
 	data := map[string]interface{}{
 		"ipv4_enabled":       ipConfiguration.Ipv4Enabled,

google/services/sql/resource_sql_database_instance_test.go

@@ -813,6 +813,52 @@ func TestAccSqlDatabaseInstance_withPrivateNetwork_withoutAllocatedIpRange(t *te
 	})
 }
 
+func TestAccSqlDatabaseInstance_withMCPEnabled(t *testing.T) {
+	t.Parallel()
+
+	instanceName := "tf-test-" + acctest.RandString(t, 10)
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccSqlDatabaseInstance_withMCPEnabled(instanceName),
+			},
+			{
+				ResourceName:            "google_sql_database_instance.instance",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"deletion_protection"},
+			},
+		},
+	})
+}
+
+func TestAccSqlDatabaseInstance_withoutMCPEnabled(t *testing.T) {
+	t.Parallel()
+
+	instanceName := "tf-test-" + acctest.RandString(t, 10)
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccSqlDatabaseInstance_withoutMCPEnabled(instanceName),
+			},
+			{
+				ResourceName:            "google_sql_database_instance.instance",
+				ImportState:             true,
+				ImportStateVerify:       true,
+				ImportStateVerifyIgnore: []string{"deletion_protection"},
+			},
+		},
+	})
+}
+
 func TestAccSqlDatabaseInstance_withPSCEnabled_withoutAllowedConsumerProjects(t *testing.T) {
 	t.Parallel()
 
@@ -4727,6 +4773,41 @@ func verifyPscAutoConnectionsOperation(resourceName string, isPscConfigExpected
 	}
 }
 
+func testAccSqlDatabaseInstance_withoutMCPEnabled(instanceName string) string {
+	return fmt.Sprintf(`
+resource "google_sql_database_instance" "instance" {
+  name                = "%s"
+  region              = "us-central1"
+  database_version    = "POSTGRES_16"
+  deletion_protection = false
+  settings {
+    tier = "db-perf-optimized-N-2"
+  }
+}
+`, instanceName)
+}
+
+func testAccSqlDatabaseInstance_withMCPEnabled(instanceName string) string {
+	return fmt.Sprintf(`
+resource "google_sql_database_instance" "instance" {
+  name                = "%s"
+  region              = "us-central1"
+  database_version    = "POSTGRES_16"
+  deletion_protection = false
+  settings {
+    tier = "db-perf-optimized-N-2"
+	connection_pool_config {
+		connection_pooling_enabled = true
+		flags {
+			name = "max_client_connections"
+			value = "1980"
+		}
+	}
+  }
+}
+`, instanceName)
+}
+
 func testAccSqlDatabaseInstance_withPSCEnabled_withoutPscAutoConnections(instanceName string) string {
 	return fmt.Sprintf(`
 resource "google_sql_database_instance" "instance" {

website/docs/r/sql_database_instance.html.markdown

@@ -173,6 +173,25 @@ resource "google_sql_database_instance" "main" {
 }
 ```
 
+### Cloud SQL Instance with MCP
+```hcl
+resource "google_sql_database_instance" "instance" {
+  name:            = "mcp-enabled-main-instance"
+  region           = "us-central1"
+  database_version = "POSTGRES_16"
+  settings {
+    tier = "db-perf-optimized-N-2"
+	  connection_pool_config {
+		  connection_pooling_enabled = true
+      flags {
+			  name = "max_client_connections"
+			  value = "1980"
+		  }
+	  }
+  }
+}
+```
+
 ### Cloud SQL Instance with PSC connectivity
 
 ```hcl
@@ -571,6 +590,16 @@ The optional, computed `replication_cluster` block represents a primary instance
 
 * `dr_replica`: Read-only field that indicates whether the replica is a DR replica.
 
+The optional `settings.connection_pool_config` subblock supports:
+
+* `connection_pooling_enabled`: (Optional) True if the manager connection pooling configuration is enabled.
+
+The optional `settings.connection_pool_config.flags` sublist supports:
+
+* `name` - (Required) Name of the flag.
+
+* `value` - (Required) Value of the flag.
+
 ## Attributes Reference
 
 In addition to the arguments listed above, the following computed attributes are