fixing database id restriction

affonsov · affonsov · commit 5dce9ca034a9 · 2025-08-27T09:53:53.000-07:00
Signed-off-by: affonsov &lt;67347924+affonsov@users.noreply.github.com&gt;
diff --git a/java/client/src/main/java/glide/api/models/configuration/BaseClientConfiguration.java b/java/client/src/main/java/glide/api/models/configuration/BaseClientConfiguration.java
@@ -87,10 +87,15 @@ public abstract class BaseClientConfiguration {
 
     /**
      * Index of the logical database to connect to. Must be non-negative and within the range
-     * supported by the server. If not specified, defaults to database 0.
+     * supported by the server configuration. If not specified, defaults to database 0.
      *
-     * <p>For cluster mode, this feature requires Valkey 9.0+ with multi-database cluster support
-     * enabled (cluster-databases configuration > 1).
+     * <p>The valid range is determined by the server's database configuration. For standalone mode,
+     * this is typically 0-15 by default but can be configured via the 'databases' setting. For
+     * cluster mode, this feature requires Valkey 9.0+ with multi-database cluster support enabled
+     * (cluster-databases configuration > 1).
+     *
+     * <p>Client-side validation only checks for non-negative values. Range validation is performed
+     * server-side and will result in a connection error if the specified database ID is out of range.
      */
     private final Integer databaseId;
 
diff --git a/java/client/src/main/java/glide/managers/ConnectionManager.java b/java/client/src/main/java/glide/managers/ConnectionManager.java
@@ -167,11 +167,6 @@ private ConnectionRequest.Builder setupConnectionRequestBuilderBaseConfiguration
                 throw new ConfigurationError(
                         "databaseId must be non-negative, got: " + configuration.getDatabaseId());
             }
-            if (configuration.getDatabaseId() > 15) {
-                throw new ConfigurationError(
-                        "databaseId must be within reasonable range (0-15), got: "
-                                + configuration.getDatabaseId());
-            }
             connectionRequestBuilder.setDatabaseId(configuration.getDatabaseId());
         }
 
diff --git a/java/client/src/main/java/redis/clients/jedis/ClusterConfigurationMapper.java b/java/client/src/main/java/redis/clients/jedis/ClusterConfigurationMapper.java
@@ -102,10 +102,6 @@ public static GlideClusterClientConfiguration createDefaultClusterConfig(
      */
     public static void validateClusterConfiguration(JedisClientConfig jedisConfig) {
         // Check for unsupported cluster features
-        if (jedisConfig.getDatabase() != 0) {
-            logger.warning("Database selection is not supported in cluster mode");
-        }
-
         if (jedisConfig.getBlockingSocketTimeoutMillis() > 0) {
             logger.warning(
                     "Blocking socket timeout configuration may not be fully supported in cluster mode");
diff --git a/java/client/src/test/java/glide/api/models/configuration/BaseClientConfigurationTest.java b/java/client/src/test/java/glide/api/models/configuration/BaseClientConfigurationTest.java
@@ -61,9 +61,10 @@ public void testDatabaseIdValidValues() {
     }
 
     @ParameterizedTest
-    @ValueSource(ints = {0, 1, 5, 10, 15})
+    @ValueSource(ints = {0, 1, 5, 10, 15, 50, 100, 1000})
     public void testDatabaseIdValidRange(int databaseId) {
-        // Test that valid database IDs are accepted
+        // Test that non-negative database IDs are accepted (server-side validation will handle range
+        // checks)
         TestClientConfiguration config =
                 TestClientConfiguration.builder().databaseId(databaseId).build();
         assertEquals(databaseId, config.getDatabaseId());
@@ -78,11 +79,20 @@ public void testDatabaseIdNegativeValue() {
 
     @Test
     public void testDatabaseIdLargeValue() {
-        // Test that large database IDs are handled (validation should be done at connection time)
+        // Test that large database IDs are handled (server-side validation will handle range checks)
         TestClientConfiguration config = TestClientConfiguration.builder().databaseId(100).build();
         assertEquals(100, config.getDatabaseId());
     }
 
+    @ParameterizedTest
+    @ValueSource(ints = {999, 10000, 50000})
+    public void testDatabaseIdVeryLargeValues(int databaseId) {
+        // Test that very large database IDs are accepted by client (server will validate range)
+        TestClientConfiguration config =
+                TestClientConfiguration.builder().databaseId(databaseId).build();
+        assertEquals(databaseId, config.getDatabaseId());
+    }
+
     @Test
     public void testDatabaseIdWithOtherConfiguration() {
         // Test that databaseId works with other configuration options
diff --git a/java/integTest/src/test/java/glide/MultiDatabaseTests.java b/java/integTest/src/test/java/glide/MultiDatabaseTests.java
@@ -44,6 +44,11 @@ private static Stream<Arguments> getDatabaseIds() {
                 Arguments.of(0), Arguments.of(1), Arguments.of(2), Arguments.of(5), Arguments.of(10));
     }
 
+    /** Helper method to provide larger database IDs for server validation testing */
+    private static Stream<Arguments> getLargeDatabaseIds() {
+        return Stream.of(Arguments.of(50), Arguments.of(100), Arguments.of(999));
+    }
+
     @ParameterizedTest
     @MethodSource("getClients")
     @SneakyThrows
@@ -216,21 +221,26 @@ public void testInvalidNegativeDatabaseId(int invalidDatabaseId) {
     }
 
     @ParameterizedTest
-    @ValueSource(ints = {16, 20, 100})
+    @ValueSource(ints = {50, 100, 999})
     @SneakyThrows
-    public void testInvalidLargeDatabaseId(int invalidDatabaseId) {
-        // Test that database IDs beyond reasonable range result in configuration errors
-        ConfigurationError exception =
-                assertThrows(
-                        ConfigurationError.class,
-                        () -> {
-                            GlideClient.createClient(commonClientConfig().databaseId(invalidDatabaseId).build())
-                                    .get();
-                        });
-
-        // Should contain information about the reasonable range
-        assertTrue(exception.getMessage().toLowerCase().contains("reasonable range"));
-        assertTrue(exception.getMessage().contains(String.valueOf(invalidDatabaseId)));
+    public void testLargeDatabaseIdServerValidation(int databaseId) {
+        // Test that large database IDs are handled by server-side validation
+        // The client should accept these values, but the server may reject them based on its
+        // configuration
+        try {
+            GlideClient client =
+                    GlideClient.createClient(commonClientConfig().databaseId(databaseId).build()).get();
+            // If we reach here, the server supports this database ID
+            client.close();
+        } catch (ExecutionException e) {
+            // Server-side validation should provide appropriate error messages
+            // This is expected behavior for out-of-range database IDs
+            assertTrue(
+                    e.getMessage().toLowerCase().contains("database")
+                            || e.getMessage().toLowerCase().contains("db")
+                            || e.getMessage().toLowerCase().contains("select")
+                            || e.getMessage().toLowerCase().contains("invalid"));
+        }
     }
 
     @Test
@@ -256,4 +266,30 @@ public void testClusterClientWithNonZeroDatabaseOnOlderServer() {
                         || exception.getMessage().toLowerCase().contains("cluster")
                         || exception.getMessage().toLowerCase().contains("database"));
     }
+
+    @ParameterizedTest
+    @MethodSource("getLargeDatabaseIds")
+    @EnabledIf("isServerVersionAtLeast9_0")
+    @SneakyThrows
+    public void testClusterClientLargeDatabaseIdServerValidation(int databaseId) {
+        // Test that large database IDs in cluster mode are handled by server-side validation
+        assumeTrue(isServerVersionAtLeast9_0(), "Multi-DB cluster mode requires Valkey 9.0+");
+
+        try {
+            GlideClusterClient client =
+                    GlideClusterClient.createClient(
+                                    commonClusterClientConfig().databaseId(databaseId).build())
+                            .get();
+            // If we reach here, the server supports this database ID
+            client.close();
+        } catch (ExecutionException e) {
+            // Server-side validation should provide appropriate error messages
+            // This is expected behavior for out-of-range database IDs
+            assertTrue(
+                    e.getMessage().toLowerCase().contains("database")
+                            || e.getMessage().toLowerCase().contains("db")
+                            || e.getMessage().toLowerCase().contains("select")
+                            || e.getMessage().toLowerCase().contains("invalid"));
+        }
+    }
 }
diff --git a/java/integTest/src/test/java/glide/SharedCommandTests.java b/java/integTest/src/test/java/glide/SharedCommandTests.java
@@ -7,7 +7,6 @@
 import static glide.TestUtilities.commonClusterClientConfig;
 import static glide.api.BaseClient.OK;
 import static glide.api.models.GlideString.gs;
-import static glide.api.models.configuration.RequestRoutingConfiguration.SimpleMultiNodeRoute.ALL_NODES;
 import static glide.api.models.commands.LInsertOptions.InsertPosition.AFTER;
 import static glide.api.models.commands.LInsertOptions.InsertPosition.BEFORE;
 import static glide.api.models.commands.RangeOptions.InfScoreBound.NEGATIVE_INFINITY;
@@ -19,6 +18,7 @@
 import static glide.api.models.commands.SetOptions.Expiry.Milliseconds;
 import static glide.api.models.commands.SortBaseOptions.OrderBy.ASC;
 import static glide.api.models.commands.SortBaseOptions.OrderBy.DESC;
+import static glide.api.models.configuration.RequestRoutingConfiguration.SimpleMultiNodeRoute.ALL_NODES;
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -110,7 +110,6 @@
 import glide.api.models.commands.stream.StreamReadOptions;
 import glide.api.models.commands.stream.StreamTrimOptions.MaxLen;
 import glide.api.models.commands.stream.StreamTrimOptions.MinId;
-import glide.api.models.configuration.GlideClientConfiguration;
 import glide.api.models.configuration.ProtocolVersion;
 import glide.api.models.exceptions.RequestException;
 import glide.cluster.ValkeyCluster;

Original file line number	Diff line number	Diff line change
`@@ -167,11 +167,6 @@ private ConnectionRequest.Builder setupConnectionRequestBuilderBaseConfiguration`
`167`	`167`	`throw new ConfigurationError(`
`168`	`168`	`"databaseId must be non-negative, got: " + configuration.getDatabaseId());`
`169`	`169`	`}`
`170`		`- if (configuration.getDatabaseId() > 15) {`
`171`		`- throw new ConfigurationError(`
`172`		`- "databaseId must be within reasonable range (0-15), got: "`
`173`		`- + configuration.getDatabaseId());`
`174`		`- }`
`175`	`170`	`connectionRequestBuilder.setDatabaseId(configuration.getDatabaseId());`
`176`	`171`	`}`
`177`	`172`