[Backport 2.1] Go: Add Multi-Database Support for Cluster Mode Valkey 9.0 (#4696)

Go: Add Multi-Database Support for Cluster Mode Valkey 9.0 (#4660)

* - Implement database selection for cluster clients when database_id != 0
- Send SELECT command to all cluster nodes using MultiNode routing
- Add comprehensive error handling with clear error messages
- Include test for database selection error handling in cluster mode
- Support backward compatibility with servers that don't support multi-db cluster mode
- Enable cluster-databases=16 for Valkey 9.0+ in cluster manager

This enables cluster clients to work with non-default databases on Valkey 9.0+
servers configured with cluster-databases support, while gracefully handling
older servers that don't support this feature.



* update valkey9 multi db tests



* fix lint



* fixing valkey 9 cluster tests



* add to route to all nodes in the core



* rust lint fix



* implement database selection in cluster mode via connection parameters

- Add database_id field to ClusterParams and BuilderParams structs
- Add database() method to ClusterClientBuilder for setting database ID
- Pass database_id through connection info instead of post-connection SELECT
- Remove SELECT command from cluster routing
- Remove post-connection SELECT command logic from create_cluster_client
- Add comprehensive tests for database isolation and reconnection behavior
- Verify database ID persistence across node reconnections
- Test multi-database cluster support with proper isolation verification

This change moves database selection from a post-connection SELECT command
to a connection parameter, which is more reliable for cluster mode and
handles reconnections automatically. The approach works with servers that
support multi-database cluster configurations (like Valkey 9.0+).



* add valkey9 constraint in the core tests



* fix core test not skipping test when version was lower than valkey 9



* Fix version check



* refactored test test_set_database_id_after_reconnection to be similar from standalone
removed is_valkey_9_or_higher



* removed tests and cleanup



* renamed builder.database to builder.database_id



* go: Add multi-database support for cluster mode clients

- Add DatabaseId field to baseClientConfiguration for both standalone and cluster clients
- Implement WithDatabaseId() method for ClusterClientConfiguration
- Add database ID validation with proper error handling for negative values
- Refactor standalone client to use shared database ID logic from base configuration
- Add Select() and SelectWithOptions() methods for cluster clients with routing support
- Include comprehensive test coverage for database isolation, reconnection persistence, and error handling
- Add backward compatibility support - clients default to database 0 when no database_id specified
- Add server version compatibility checks (cluster multi-database requires Valkey 9.0+)
- Update documentation with warnings about SELECT command limitations and recommended configuration approach

This enables cluster mode clients to connect to specific databases at initialization time,
with the database selection persisting across reconnections, unlike the SELECT command
which resets on reconnection.



* fixed go tests
- batch tests
- database id tests



* removed selectWithOptions



* go: Remove Select command from cluster clients

- Remove Select method from ClusterClient and related interfaces
- Delete comprehensive database_id integration tests
- Remove Select command from batch operations
- Remove Select examples and tests
- Add example for cluster client with database_id configuration

The Select command is being removed in favor of using the database_id
configuration parameter, which provides persistent database selection
across reconnections.



* remove config validation
simplified tests



* added changelog



* removing batch test, and readding standalone select and removing batch select



---------

Signed-off-by: affonsov <67347924+affonsov@users.noreply.github.com>

Author: affonsov

CHANGELOG.md

@@ -6,6 +6,7 @@
 * JAVA: Valkey 9 new commands HASH items expiration ([#4556](https://github.com/valkey-io/valkey-glide/pull/4556))
 * NODE: Valkey 9 support - Add Hash Field Expiration Commands Support ([#4598](https://github.com/valkey-io/valkey-glide/pull/4598))
 * Python: Valkey 9 new hash field expiration commands ([#4610](https://github.com/valkey-io/valkey-glide/pull/4610))
+* Go: Add Multi-Database Support for Cluster Mode Valkey 9.0 ([#4660](https://github.com/valkey-io/valkey-glide/pull/4660))
 * Python: Add Multi-Database Support for Cluster Mode Valkey 9.0 ([#4659](https://github.com/valkey-io/valkey-glide/pull/4659))
 
 #### Fixes

go/config/config.go

@@ -102,6 +102,7 @@ type baseClientConfiguration struct {
 	clientAZ          string
 	reconnectStrategy *BackoffStrategy
 	lazyConnect       bool
+	DatabaseId        *int `json:"database_id,omitempty"`
 }
 
 func (config *baseClientConfiguration) toProtobuf() (*protobuf.ConnectionRequest, error) {
@@ -152,6 +153,10 @@ func (config *baseClientConfiguration) toProtobuf() (*protobuf.ConnectionRequest
 		request.LazyConnect = config.lazyConnect
 	}
 
+	if config.DatabaseId != nil {
+		request.DatabaseId = uint32(*config.DatabaseId)
+	}
+
 	return &request, nil
 }
 
@@ -214,7 +219,6 @@ func (strategy *BackoffStrategy) toProtobuf() *protobuf.ConnectionRetryStrategy
 // ClientConfiguration represents the configuration settings for a Standalone client.
 type ClientConfiguration struct {
 	baseClientConfiguration
-	databaseId         int
 	subscriptionConfig *StandaloneSubscriptionConfig
 	AdvancedClientConfiguration
 }
@@ -232,9 +236,6 @@ func (config *ClientConfiguration) ToProtobuf() (*protobuf.ConnectionRequest, er
 	}
 	request.ClusterModeEnabled = false
 
-	if config.databaseId != 0 {
-		request.DatabaseId = uint32(config.databaseId)
-	}
 	if config.subscriptionConfig != nil && len(config.subscriptionConfig.subscriptions) > 0 {
 		request.PubsubSubscriptions = config.subscriptionConfig.toProtobuf()
 	}
@@ -330,7 +331,7 @@ func (config *ClientConfiguration) WithReconnectStrategy(strategy *BackoffStrate
 
 // WithDatabaseId sets the index of the logical database to connect to.
 func (config *ClientConfiguration) WithDatabaseId(id int) *ClientConfiguration {
-	config.databaseId = id
+	config.DatabaseId = &id
 	return config
 }
 
@@ -481,6 +482,12 @@ func (config *ClusterClientConfiguration) WithReconnectStrategy(
 	return config
 }
 
+// WithDatabaseId sets the index of the logical database to connect to.
+func (config *ClusterClientConfiguration) WithDatabaseId(id int) *ClusterClientConfiguration {
+	config.DatabaseId = &id
+	return config
+}
+
 // WithAdvancedConfiguration sets the advanced configuration settings for the client.
 func (config *ClusterClientConfiguration) WithAdvancedConfiguration(
 	advancedConfig *AdvancedClusterClientConfiguration,

go/config/config_test.go

@@ -340,3 +340,54 @@ func TestConfig_LazyConnect(t *testing.T) {
 
 	assert.False(t, defaultClusterResult.LazyConnect)
 }
+
+func TestConfig_DatabaseId(t *testing.T) {
+	// Test standalone client with database ID
+	standaloneConfig := NewClientConfiguration().WithDatabaseId(5)
+	standaloneResult, err := standaloneConfig.ToProtobuf()
+	if err != nil {
+		t.Fatalf("Failed to convert standalone config to protobuf: %v", err)
+	}
+	assert.Equal(t, uint32(5), standaloneResult.DatabaseId)
+
+	// Test cluster client with database ID
+	clusterConfig := NewClusterClientConfiguration().WithDatabaseId(3)
+	clusterResult, err := clusterConfig.ToProtobuf()
+	if err != nil {
+		t.Fatalf("Failed to convert cluster config to protobuf: %v", err)
+	}
+	assert.Equal(t, uint32(3), clusterResult.DatabaseId)
+
+	// Test default behavior (no database ID set)
+	defaultStandaloneConfig := NewClientConfiguration()
+	defaultStandaloneResult, err := defaultStandaloneConfig.ToProtobuf()
+	if err != nil {
+		t.Fatalf("Failed to convert default standalone config to protobuf: %v", err)
+	}
+	assert.Equal(t, uint32(0), defaultStandaloneResult.DatabaseId)
+
+	defaultClusterConfig := NewClusterClientConfiguration()
+	defaultClusterResult, err := defaultClusterConfig.ToProtobuf()
+	if err != nil {
+		t.Fatalf("Failed to convert default cluster config to protobuf: %v", err)
+	}
+	assert.Equal(t, uint32(0), defaultClusterResult.DatabaseId)
+}
+
+func TestConfig_DatabaseId_BaseConfiguration(t *testing.T) {
+	// Test that database_id is properly handled in base configuration for both client types
+
+	// Test standalone client inherits database_id from base configuration
+	standaloneConfig := NewClientConfiguration().WithDatabaseId(5)
+	standaloneResult, err := standaloneConfig.ToProtobuf()
+	assert.NoError(t, err)
+	assert.Equal(t, uint32(5), standaloneResult.DatabaseId)
+	assert.False(t, standaloneResult.ClusterModeEnabled)
+
+	// Test cluster client inherits database_id from base configuration
+	clusterConfig := NewClusterClientConfiguration().WithDatabaseId(3)
+	clusterResult, err := clusterConfig.ToProtobuf()
+	assert.NoError(t, err)
+	assert.Equal(t, uint32(3), clusterResult.DatabaseId)
+	assert.True(t, clusterResult.ClusterModeEnabled)
+}

go/create_client_test.go

@@ -54,3 +54,27 @@ func ExampleNewClusterClient() {
 	// Output:
 	// Client created and connected: *glide.ClusterClient
 }
+
+func ExampleNewClusterClient_withDatabaseId() {
+	// This WithDatabaseId for cluster requires Valkey 9.0+
+	clientConf := config.NewClusterClientConfiguration().
+		WithAddress(&getClusterAddresses()[0]).
+		WithRequestTimeout(5 * time.Second).
+		WithUseTLS(false).
+		WithDatabaseId(1).
+		WithSubscriptionConfig(
+			config.NewClusterSubscriptionConfig().
+				WithSubscription(config.PatternClusterChannelMode, "news.*").
+				WithCallback(func(message *models.PubSubMessage, ctx any) {
+					fmt.Printf("Received message on '%s': %s", message.Channel, message.Message)
+				}, nil),
+		)
+	client, err := NewClusterClient(clientConf)
+	if err != nil {
+		fmt.Println("Failed to create a client and connect: ", err)
+	}
+	fmt.Printf("Client created and connected: %T", client)
+
+	// Output:
+	// Client created and connected: *glide.ClusterClient
+}

go/glide_client.go

@@ -210,6 +210,20 @@ func (client *Client) ConfigGet(ctx context.Context, args []string) (map[string]
 
 // Select changes the currently selected database.
 //
+// WARNING: This command is NOT RECOMMENDED for production use.
+// Upon reconnection, the client will revert to the database_id specified
+// in the client configuration (default: 0), NOT the database selected
+// via this command.
+//
+// RECOMMENDED APPROACH: Use the database_id parameter in client
+// configuration instead:
+//
+//	config := &config.ClientConfiguration{
+//		Addresses: []config.NodeAddress{{Host: "localhost", Port: 6379}},
+//		DatabaseId: &databaseId, // Recommended: persists across reconnections
+//	}
+//	client, err := NewClient(config)
+//
 // See [valkey.io] for details.
 //
 // Parameters: