add support for advanced mysql config get and patch operations

commands/databases.go

@@ -2659,6 +2659,7 @@ For a full list of available fields, see the API documentation: https://docs.dig
 		displayerType(&displayers.MySQLConfiguration{}),
 		displayerType(&displayers.PostgreSQLConfiguration{}),
 		displayerType(&displayers.AdvancedPostgresConfiguration{}),
+		displayerType(&displayers.AdvancedMySQLConfiguration{}),
 		displayerType(&displayers.RedisConfiguration{}),
 		displayerType(&displayers.ValkeyConfiguration{}),
 		displayerType(&displayers.MongoDBConfiguration{}),
@@ -2719,17 +2720,18 @@ func RunDatabaseConfigurationGet(c *CmdConfig) error {
 	}
 
 	allowedEngines := map[string]any{
-		"mysql":       nil,
-		"pg":          nil,
-		"advanced_pg": nil,
-		"redis":       nil,
-		"valkey":      nil,
-		"mongodb":     nil,
-		"kafka":       nil,
-		"opensearch":  nil,
+		"mysql":          nil,
+		"pg":             nil,
+		"advanced_pg":    nil,
+		"advanced_mysql": nil,
+		"redis":          nil,
+		"valkey":         nil,
+		"mongodb":        nil,
+		"kafka":          nil,
+		"opensearch":     nil,
 	}
 	if _, ok := allowedEngines[engine]; !ok {
-		return fmt.Errorf("(%s) command: engine must be one of: 'pg', 'advanced_pg', 'mysql', 'redis', 'valkey', 'mongodb', 'kafka', opensearch", c.NS)
+		return fmt.Errorf("(%s) command: engine must be one of: 'pg', 'advanced_pg', 'mysql', 'advanced_mysql', 'redis', 'valkey', 'mongodb', 'kafka', opensearch", c.NS)
 	}
 
 	dbId := args[0]
@@ -2763,6 +2765,16 @@ func RunDatabaseConfigurationGet(c *CmdConfig) error {
 			AdvancedPostgresConfig: *config,
 		}
 		return c.Display(&displayer)
+	} else if engine == "advanced_mysql" {
+		config, err := c.Databases().GetAdvancedMySQLConfiguration(dbId)
+		if err != nil {
+			return err
+		}
+
+		displayer := displayers.AdvancedMySQLConfiguration{
+			AdvancedMySQLConfig: *config,
+		}
+		return c.Display(&displayer)
 	} else if engine == "redis" {
 		config, err := c.Databases().GetRedisConfiguration(dbId)
 		if err != nil {
@@ -2833,17 +2845,18 @@ func RunDatabaseConfigurationUpdate(c *CmdConfig) error {
 	}
 
 	allowedEngines := map[string]any{
-		"mysql":       nil,
-		"pg":          nil,
-		"advanced_pg": nil,
-		"redis":       nil,
-		"valkey":      nil,
-		"mongodb":     nil,
-		"kafka":       nil,
-		"opensearch":  nil,
+		"mysql":          nil,
+		"pg":             nil,
+		"advanced_pg":    nil,
+		"advanced_mysql": nil,
+		"redis":          nil,
+		"valkey":         nil,
+		"mongodb":        nil,
+		"kafka":          nil,
+		"opensearch":     nil,
 	}
 	if _, ok := allowedEngines[engine]; !ok {
-		return fmt.Errorf("(%s) command: engine must be one of: 'pg', 'advanced_pg', 'mysql', 'redis', 'valkey', 'mongodb', 'kafka', 'opensearch'", c.NS)
+		return fmt.Errorf("(%s) command: engine must be one of: 'pg', 'advanced_pg', 'mysql', 'advanced_mysql', 'redis', 'valkey', 'mongodb', 'kafka', 'opensearch'", c.NS)
 	}
 
 	configJson, err := c.Doit.GetString(c.NS, doctl.ArgDatabaseConfigJson)
@@ -2867,6 +2880,11 @@ func RunDatabaseConfigurationUpdate(c *CmdConfig) error {
 		if err != nil {
 			return err
 		}
+	} else if engine == "advanced_mysql" {
+		err := c.Databases().UpdateAdvancedMySQLConfiguration(dbId, configJson)
+		if err != nil {
+			return err
+		}
 	} else if engine == "redis" {
 		err := c.Databases().UpdateRedisConfiguration(dbId, configJson)
 		if err != nil {

commands/databases_test.go

@@ -232,6 +232,19 @@ var (
 		},
 	}
 
+	testAdvancedMySQLConfiguration = do.AdvancedMySQLConfig{
+		AdvancedMySQLConfig: &godo.AdvancedMySQLConfig{
+			MySQLParameters: []godo.AdvancedMySQLParameter{
+				{
+					Name:            "max_connections",
+					Value:           "151",
+					DefaultValue:    "151",
+					RequiresRestart: false,
+				},
+			},
+		},
+	}
+
 	testRedisConfiguration = do.RedisConfig{
 		RedisConfig: &godo.RedisConfig{},
 	}
@@ -1796,6 +1809,16 @@ func TestDatabaseConfigurationGet(t *testing.T) {
 		assert.NoError(t, err)
 	})
 
+	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
+		tm.databases.EXPECT().GetAdvancedMySQLConfiguration(testDBCluster.ID).Return(&testAdvancedMySQLConfiguration, nil)
+		config.Args = append(config.Args, testDBCluster.ID)
+		config.Doit.Set(config.NS, doctl.ArgDatabaseEngine, "advanced_mysql")
+
+		err := RunDatabaseConfigurationGet(config)
+
+		assert.NoError(t, err)
+	})
+
 	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
 		tm.databases.EXPECT().GetRedisConfiguration(testDBCluster.ID).Return(&testRedisConfiguration, nil)
 		config.Args = append(config.Args, testDBCluster.ID)
@@ -1890,6 +1913,16 @@ func TestDatabaseConfigurationUpdate(t *testing.T) {
 		assert.NoError(t, err)
 	})
 
+	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
+		tm.databases.EXPECT().UpdateAdvancedMySQLConfiguration(testDBCluster.ID, "").Return(nil)
+		config.Args = append(config.Args, testDBCluster.ID)
+		config.Doit.Set(config.NS, doctl.ArgDatabaseEngine, "advanced_mysql")
+
+		err := RunDatabaseConfigurationUpdate(config)
+
+		assert.NoError(t, err)
+	})
+
 	withTestClient(t, func(config *CmdConfig, tm *tcMocks) {
 		tm.databases.EXPECT().UpdateRedisConfiguration(testDBCluster.ID, "").Return(nil)
 		config.Args = append(config.Args, testDBCluster.ID)

commands/displayers/database.go

@@ -2382,6 +2382,50 @@ func (dc *AdvancedPostgresConfiguration) KV() []map[string]any {
 	return o
 }
 
+type AdvancedMySQLConfiguration struct {
+	AdvancedMySQLConfig do.AdvancedMySQLConfig
+}
+
+var _ Displayable = &AdvancedMySQLConfiguration{}
+
+func (dc *AdvancedMySQLConfiguration) JSON(out io.Writer) error {
+	return writeJSON(dc.AdvancedMySQLConfig, out)
+}
+
+func (dc *AdvancedMySQLConfiguration) Cols() []string {
+	return []string{
+		"Name",
+		"Value",
+		"Default Value",
+		"Requires Restart",
+		"Description",
+	}
+}
+
+func (dc *AdvancedMySQLConfiguration) ColMap() map[string]string {
+	return map[string]string{
+		"Name":             "Name",
+		"Value":            "Value",
+		"Default Value":    "Default Value",
+		"Requires Restart": "Requires Restart",
+		"Description":      "Description",
+	}
+}
+
+func (dc *AdvancedMySQLConfiguration) KV() []map[string]any {
+	o := []map[string]any{}
+	for _, p := range dc.AdvancedMySQLConfig.MySQLParameters {
+		o = append(o, map[string]any{
+			"Name":             p.Name,
+			"Value":            p.Value,
+			"Default Value":    p.DefaultValue,
+			"Requires Restart": p.RequiresRestart,
+			"Description":      p.Description,
+		})
+	}
+	return o
+}
+
 type DatabaseEvents struct {
 	DatabaseEvents do.DatabaseEvents
 }

do/databases.go

@@ -125,6 +125,11 @@ type AdvancedPostgresConfig struct {
 	*godo.AdvancedPostgresConfig
 }
 
+// AdvancedMySQLConfig is a wrapper for godo.AdvancedMySQLConfig
+type AdvancedMySQLConfig struct {
+	*godo.AdvancedMySQLConfig
+}
+
 // RedisConfig is a wrapper for godo.RedisConfig
 type RedisConfig struct {
 	*godo.RedisConfig
@@ -233,6 +238,7 @@ type DatabasesService interface {
 	GetMySQLConfiguration(databaseID string) (*MySQLConfig, error)
 	GetPostgreSQLConfiguration(databaseID string) (*PostgreSQLConfig, error)
 	GetAdvancedPostgresConfiguration(databaseID string) (*AdvancedPostgresConfig, error)
+	GetAdvancedMySQLConfiguration(databaseID string) (*AdvancedMySQLConfig, error)
 	GetRedisConfiguration(databaseID string) (*RedisConfig, error)
 	GetValkeyConfiguration(databaseID string) (*ValkeyConfig, error)
 	GetMongoDBConfiguration(databaseID string) (*MongoDBConfig, error)
@@ -242,6 +248,7 @@ type DatabasesService interface {
 	UpdateMySQLConfiguration(databaseID string, confString string) error
 	UpdatePostgreSQLConfiguration(databaseID string, confString string) error
 	UpdateAdvancedPostgresConfiguration(databaseID string, confString string) error
+	UpdateAdvancedMySQLConfiguration(databaseID string, confString string) error
 	UpdateRedisConfiguration(databaseID string, confString string) error
 	UpdateValkeyConfiguration(databaseID string, confString string) error
 	UpdateMongoDBConfiguration(databaseID string, confString string) error
@@ -753,6 +760,17 @@ func (ds *databasesService) GetAdvancedPostgresConfiguration(databaseID string)
 	}, nil
 }
 
+func (ds *databasesService) GetAdvancedMySQLConfiguration(databaseID string) (*AdvancedMySQLConfig, error) {
+	cfg, _, err := ds.client.Databases.GetAdvancedMySQLConfig(context.TODO(), databaseID)
+	if err != nil {
+		return nil, err
+	}
+
+	return &AdvancedMySQLConfig{
+		AdvancedMySQLConfig: cfg,
+	}, nil
+}
+
 func (ds *databasesService) GetRedisConfiguration(databaseID string) (*RedisConfig, error) {
 	cfg, _, err := ds.client.Databases.GetRedisConfig(context.TODO(), databaseID)
 	if err != nil {
@@ -853,6 +871,21 @@ func (ds *databasesService) UpdateAdvancedPostgresConfiguration(databaseID strin
 	return nil
 }
 
+func (ds *databasesService) UpdateAdvancedMySQLConfiguration(databaseID string, confString string) error {
+	var conf godo.AdvancedMySQLConfigUpdate
+	err := json.Unmarshal([]byte(confString), &conf)
+	if err != nil {
+		return err
+	}
+
+	_, err = ds.client.Databases.UpdateAdvancedMySQLConfig(context.TODO(), databaseID, &conf)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (ds *databasesService) UpdateRedisConfiguration(databaseID string, confString string) error {
 	var conf godo.RedisConfig
 	err := json.Unmarshal([]byte(confString), &conf)