python: Add multi-database support for cluster and standalone modes

- Add database_id parameter to BaseClientConfiguration, GlideClientConfiguration, and GlideClusterClientConfiguration
- Implement SELECT command for both cluster and standalone modes with comprehensive documentation
- Add validation for database_id parameter (0-15 range, integer type)
- Refactor configuration protobuf request creation with helper methods for better maintainability
- Add extensive test coverage for database_id configuration and validation
- Include production warnings and recommended approaches in SELECT command documentation
- Support routing configuration for cluster mode SELECT operations
- Ensure database_id persists across reconnections when set in client configuration

Documentation:
- Added comprehensive docstrings with warnings about SELECT command limitations
- Included examples showing recommended database_id configuration approach
- Documented reconnection behavior and cluster-specific routing requirements

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

Author: affonsov

python/glide-async/python/glide/async_commands/cluster_commands.py

@@ -1029,6 +1029,64 @@ async def flushall(
             await self._execute_command(RequestType.FlushAll, args, route),
         )
 
+    async def select(
+        self, index: int, route: Optional[Route] = None
+    ) -> TClusterResponse[TOK]:
+        """
+        Change the currently selected database on cluster nodes.
+
+        **WARNING**: This command is NOT RECOMMENDED for production use.
+        Upon reconnection, nodes 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:
+
+        ```python
+        client = await GlideClusterClient.create_client(
+            GlideClusterClientConfiguration(
+                addresses=[NodeAddress("localhost", 6379)],
+                database_id=5  # Recommended: persists across reconnections
+            )
+        )
+        ```
+
+        **CLUSTER BEHAVIOR**: This command routes to all nodes by default
+        to maintain consistency across the cluster.
+
+        **RECONNECTION BEHAVIOR**: After any reconnection (due to network issues,
+        timeouts, etc.), nodes will automatically revert to the database_id
+        specified during client creation, losing any database selection made via
+        this SELECT command.
+
+        See [valkey.io](https://valkey.io/commands/select/) for details.
+
+        Args:
+            index (int): The index of the database to select.
+            route (Optional[Route]): The command will be routed to all nodes by default,
+                unless `route` is provided, in which case the client will route the command
+                to the nodes defined by `route`.
+
+        Returns:
+            TClusterResponse[TOK]: A simple OK response from each node.
+
+        Examples:
+            >>> await client.select(1)
+                'OK'  # All nodes in the cluster have selected database 1
+            >>> await client.select(2, AllNodes())
+                'OK'  # Explicitly route to all nodes
+        """
+        from glide_shared.routes import AllNodes
+
+        if route is None:
+            route = AllNodes()  # Default routing for cluster mode
+
+        return cast(
+            TClusterResponse[TOK],
+            await self._execute_command(RequestType.Select, [str(index)], route),
+        )
+
     async def flushdb(
         self, flush_mode: Optional[FlushMode] = None, route: Optional[Route] = None
     ) -> TOK:

python/glide-async/python/glide/async_commands/standalone_commands.py

@@ -166,6 +166,28 @@ async def select(self, index: int) -> TOK:
         """
         Change 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:
+
+        ```python
+        client = await GlideClient.create_client(
+            GlideClientConfiguration(
+                addresses=[NodeAddress("localhost", 6379)],
+                database_id=5  # Recommended: persists across reconnections
+            )
+        )
+        ```
+
+        **RECONNECTION BEHAVIOR**: After any reconnection (due to network issues,
+        timeouts, etc.), the client will automatically revert to the database_id
+        specified during client creation, losing any database selection made via
+        this SELECT command.
+
         See [valkey.io](https://valkey.io/commands/select/) for details.
 
         Args:

python/glide-shared/glide_shared/config.py

@@ -249,6 +249,8 @@ class BaseClientConfiguration:
         reconnect_strategy (Optional[BackoffStrategy]): Strategy used to determine how and when to reconnect, in case of
             connection failures.
             If not set, a default backoff strategy will be used.
+        database_id (Optional[int]): Index of the logical database to connect to.
+            If not set, the client will connect to database 0.
         client_name (Optional[str]): Client name to be used for the client. Will be used with CLIENT SETNAME command
             during connection establishment.
         protocol (ProtocolVersion): Serialization protocol to be used. If not set, `RESP3` will be used.
@@ -292,6 +294,7 @@ def __init__(
         read_from: ReadFrom = ReadFrom.PRIMARY,
         request_timeout: Optional[int] = None,
         reconnect_strategy: Optional[BackoffStrategy] = None,
+        database_id: Optional[int] = None,
         client_name: Optional[str] = None,
         protocol: ProtocolVersion = ProtocolVersion.RESP3,
         inflight_requests_limit: Optional[int] = None,
@@ -305,13 +308,23 @@ def __init__(
         self.read_from = read_from
         self.request_timeout = request_timeout
         self.reconnect_strategy = reconnect_strategy
+        self.database_id = database_id
         self.client_name = client_name
         self.protocol = protocol
         self.inflight_requests_limit = inflight_requests_limit
         self.client_az = client_az
         self.advanced_config = advanced_config
         self.lazy_connect = lazy_connect
 
+        # Validate database_id parameter
+        if database_id is not None:
+            if not isinstance(database_id, int):
+                raise ValueError("database_id must be an integer")
+            if database_id < 0:
+                raise ValueError("database_id must be non-negative")
+            if database_id > 15:
+                raise ValueError("database_id must be less than or equal to 15")
+
         if read_from == ReadFrom.AZ_AFFINITY and not client_az:
             raise ValueError(
                 "client_az must be set when read_from is set to AZ_AFFINITY"
@@ -322,6 +335,39 @@ def __init__(
                 "client_az must be set when read_from is set to AZ_AFFINITY_REPLICAS_AND_PRIMARY"
             )
 
+    def _set_addresses_in_request(self, request: ConnectionRequest) -> None:
+        """Set addresses in the protobuf request."""
+        for address in self.addresses:
+            address_info = request.addresses.add()
+            address_info.host = address.host
+            address_info.port = address.port
+
+    def _set_reconnect_strategy_in_request(self, request: ConnectionRequest) -> None:
+        """Set reconnect strategy in the protobuf request."""
+        if not self.reconnect_strategy:
+            return
+
+        request.connection_retry_strategy.number_of_retries = (
+            self.reconnect_strategy.num_of_retries
+        )
+        request.connection_retry_strategy.factor = self.reconnect_strategy.factor
+        request.connection_retry_strategy.exponent_base = (
+            self.reconnect_strategy.exponent_base
+        )
+        if self.reconnect_strategy.jitter_percent is not None:
+            request.connection_retry_strategy.jitter_percent = (
+                self.reconnect_strategy.jitter_percent
+            )
+
+    def _set_credentials_in_request(self, request: ConnectionRequest) -> None:
+        """Set credentials in the protobuf request."""
+        if not self.credentials:
+            return
+
+        if self.credentials.username:
+            request.authentication_info.username = self.credentials.username
+        request.authentication_info.password = self.credentials.password
+
     def _create_a_protobuf_conn_request(
         self, cluster_mode: bool = False
     ) -> ConnectionRequest:
@@ -335,44 +381,34 @@ def _create_a_protobuf_conn_request(
             ConnectionRequest: Protobuf ConnectionRequest.
         """
         request = ConnectionRequest()
-        for address in self.addresses:
-            address_info = request.addresses.add()
-            address_info.host = address.host
-            address_info.port = address.port
+
+        # Set basic configuration
+        self._set_addresses_in_request(request)
         request.tls_mode = TlsMode.SecureTls if self.use_tls else TlsMode.NoTls
         request.read_from = self.read_from.value
+        request.cluster_mode_enabled = cluster_mode
+        request.protocol = self.protocol.value
+
+        # Set optional configuration
         if self.request_timeout:
             request.request_timeout = self.request_timeout
-        if self.reconnect_strategy:
-            request.connection_retry_strategy.number_of_retries = (
-                self.reconnect_strategy.num_of_retries
-            )
-            request.connection_retry_strategy.factor = self.reconnect_strategy.factor
-            request.connection_retry_strategy.exponent_base = (
-                self.reconnect_strategy.exponent_base
-            )
-            if self.reconnect_strategy.jitter_percent is not None:
-                request.connection_retry_strategy.jitter_percent = (
-                    self.reconnect_strategy.jitter_percent
-                )
 
-        request.cluster_mode_enabled = True if cluster_mode else False
-        if self.credentials:
-            if self.credentials.username:
-                request.authentication_info.username = self.credentials.username
-            request.authentication_info.password = self.credentials.password
+        self._set_reconnect_strategy_in_request(request)
+        self._set_credentials_in_request(request)
+
         if self.client_name:
             request.client_name = self.client_name
-        request.protocol = self.protocol.value
         if self.inflight_requests_limit:
             request.inflight_requests_limit = self.inflight_requests_limit
         if self.client_az:
             request.client_az = self.client_az
+        if self.database_id is not None:
+            request.database_id = self.database_id
         if self.advanced_config:
             self.advanced_config._create_a_protobuf_conn_request(request)
-
         if self.lazy_connect is not None:
             request.lazy_connect = self.lazy_connect
+
         return request
 
     def _is_pubsub_configured(self) -> bool:
@@ -425,7 +461,8 @@ class GlideClientConfiguration(BaseClientConfiguration):
         reconnect_strategy (Optional[BackoffStrategy]): Strategy used to determine how and when to reconnect, in case of
             connection failures.
             If not set, a default backoff strategy will be used.
-        database_id (Optional[int]): index of the logical database to connect to.
+        database_id (Optional[int]): Index of the logical database to connect to.
+            If not set, the client will connect to database 0.
         client_name (Optional[str]): Client name to be used for the client. Will be used with CLIENT SETNAME command during
             connection establishment.
         protocol (ProtocolVersion): The version of the RESP protocol to communicate with the server.
@@ -500,23 +537,21 @@ def __init__(
             read_from=read_from,
             request_timeout=request_timeout,
             reconnect_strategy=reconnect_strategy,
+            database_id=database_id,
             client_name=client_name,
             protocol=protocol,
             inflight_requests_limit=inflight_requests_limit,
             client_az=client_az,
             advanced_config=advanced_config,
             lazy_connect=lazy_connect,
         )
-        self.database_id = database_id
         self.pubsub_subscriptions = pubsub_subscriptions
 
     def _create_a_protobuf_conn_request(
         self, cluster_mode: bool = False
     ) -> ConnectionRequest:
         assert cluster_mode is False
         request = super()._create_a_protobuf_conn_request(cluster_mode)
-        if self.database_id:
-            request.database_id = self.database_id
 
         if self.pubsub_subscriptions:
             if self.protocol == ProtocolVersion.RESP2:
@@ -592,6 +627,8 @@ class GlideClusterClientConfiguration(BaseClientConfiguration):
         reconnect_strategy (Optional[BackoffStrategy]): Strategy used to determine how and when to reconnect, in case of
             connection failures.
             If not set, a default backoff strategy will be used.
+        database_id (Optional[int]): Index of the logical database to connect to.
+            If not set, the client will connect to database 0.
         client_name (Optional[str]): Client name to be used for the client. Will be used with CLIENT SETNAME command during
             connection establishment.
         protocol (ProtocolVersion): The version of the RESP protocol to communicate with the server.
@@ -661,6 +698,7 @@ def __init__(
         read_from: ReadFrom = ReadFrom.PRIMARY,
         request_timeout: Optional[int] = None,
         reconnect_strategy: Optional[BackoffStrategy] = None,
+        database_id: Optional[int] = None,
         client_name: Optional[str] = None,
         protocol: ProtocolVersion = ProtocolVersion.RESP3,
         periodic_checks: Union[
@@ -679,6 +717,7 @@ def __init__(
             read_from=read_from,
             request_timeout=request_timeout,
             reconnect_strategy=reconnect_strategy,
+            database_id=database_id,
             client_name=client_name,
             protocol=protocol,
             inflight_requests_limit=inflight_requests_limit,

python/glide-sync/glide_sync/config.py

@@ -123,6 +123,8 @@ class GlideClusterClientConfiguration(SharedGlideClusterClientConfiguration):
         reconnect_strategy (Optional[BackoffStrategy]): Strategy used to determine how and when to reconnect, in case of
             connection failures.
             If not set, a default backoff strategy will be used.
+        database_id (Optional[int]): Index of the logical database to connect to.
+            If not set, the client will connect to database 0.
         client_name (Optional[str]): Client name to be used for the client. Will be used with CLIENT SETNAME command during
             connection establishment.
         protocol (ProtocolVersion): The version of the RESP protocol to communicate with the server.
@@ -153,6 +155,7 @@ def __init__(
         read_from: ReadFrom = ReadFrom.PRIMARY,
         request_timeout: Optional[int] = None,
         reconnect_strategy: Optional[BackoffStrategy] = None,
+        database_id: Optional[int] = None,
         client_name: Optional[str] = None,
         protocol: ProtocolVersion = ProtocolVersion.RESP3,
         periodic_checks: Union[
@@ -168,9 +171,10 @@ def __init__(
             credentials=credentials,
             read_from=read_from,
             request_timeout=request_timeout,
+            reconnect_strategy=reconnect_strategy,
+            database_id=database_id,
             periodic_checks=periodic_checks,
             pubsub_subscriptions=None,
-            reconnect_strategy=reconnect_strategy,
             client_name=client_name,
             protocol=protocol,
             inflight_requests_limit=None,

python/glide-sync/glide_sync/sync_commands/cluster_commands.py

@@ -919,6 +919,64 @@ def flushall(
             self._execute_command(RequestType.FlushAll, args, route),
         )
 
+    def select(
+        self, index: int, route: Optional[Route] = None
+    ) -> TClusterResponse[TOK]:
+        """
+        Change the currently selected database on cluster nodes.
+
+        **WARNING**: This command is NOT RECOMMENDED for production use.
+        Upon reconnection, nodes 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:
+
+        ```python
+        client = GlideClusterClient.create_client(
+            GlideClusterClientConfiguration(
+                addresses=[NodeAddress("localhost", 6379)],
+                database_id=5  # Recommended: persists across reconnections
+            )
+        )
+        ```
+
+        **CLUSTER BEHAVIOR**: This command routes to all nodes by default
+        to maintain consistency across the cluster.
+
+        **RECONNECTION BEHAVIOR**: After any reconnection (due to network issues,
+        timeouts, etc.), nodes will automatically revert to the database_id
+        specified during client creation, losing any database selection made via
+        this SELECT command.
+
+        See [valkey.io](https://valkey.io/commands/select/) for details.
+
+        Args:
+            index (int): The index of the database to select.
+            route (Optional[Route]): The command will be routed to all nodes by default,
+                unless `route` is provided, in which case the client will route the command
+                to the nodes defined by `route`.
+
+        Returns:
+            TClusterResponse[TOK]: A simple OK response from each node.
+
+        Examples:
+            >>> client.select(1)
+                'OK'  # All nodes in the cluster have selected database 1
+            >>> client.select(2, AllNodes())
+                'OK'  # Explicitly route to all nodes
+        """
+        from glide_shared.routes import AllNodes
+
+        if route is None:
+            route = AllNodes()  # Default routing for cluster mode
+
+        return cast(
+            TClusterResponse[TOK],
+            self._execute_command(RequestType.Select, [str(index)], route),
+        )
+
     def flushdb(
         self, flush_mode: Optional[FlushMode] = None, route: Optional[Route] = None
     ) -> TOK: