ServerSelectionStrategy: remoe unused DB arg all the way down

StackExchange.Redis/ConnectionMultiplexer.cs

@@ -1837,9 +1837,9 @@ internal ServerEndPoint SelectServer(Message message)
             return ServerSelectionStrategy.Select(message);
         }
 
-        internal ServerEndPoint SelectServer(int db, RedisCommand command, CommandFlags flags, RedisKey key)
+        internal ServerEndPoint SelectServer(RedisCommand command, CommandFlags flags, RedisKey key)
         {
-            return ServerSelectionStrategy.Select(db, command, key, flags);
+            return ServerSelectionStrategy.Select(command, key, flags);
         }
 
         private WriteResult TryPushMessageToBridge<T>(Message message, ResultProcessor<T> processor, ResultBox<T> resultBox, ref ServerEndPoint server)

StackExchange.Redis/RedisBase.cs

@@ -54,9 +54,9 @@ internal virtual T ExecuteSync<T>(Message message, ResultProcessor<T> processor,
             return multiplexer.ExecuteSyncImpl<T>(message, processor, server);
         }
 
-        internal virtual RedisFeatures GetFeatures(int db, RedisKey key, CommandFlags flags, out ServerEndPoint server)
+        internal virtual RedisFeatures GetFeatures(RedisKey key, CommandFlags flags, out ServerEndPoint server)
         {
-            server = multiplexer.SelectServer(db, RedisCommand.PING, flags, key);
+            server = multiplexer.SelectServer(RedisCommand.PING, flags, key);
             var version = server == null ? multiplexer.RawConfig.DefaultVersion : server.Version;
             return new RedisFeatures(version);
         }

StackExchange.Redis/RedisDatabase.cs

@@ -485,7 +485,7 @@ public Task<bool> HyperLogLogAddAsync(RedisKey key, RedisValue[] values, Command
 
         public long HyperLogLogLength(RedisKey key, CommandFlags flags = CommandFlags.None)
         {
-            var features = GetFeatures(Database, key, flags, out ServerEndPoint server);
+            var features = GetFeatures(key, flags, out ServerEndPoint server);
             var cmd = Message.Create(Database, flags, RedisCommand.PFCOUNT, key);
             // technically a write / master-only command until 2.8.18
             if (server != null && !features.HyperLogLogCountSlaveSafe) cmd.SetMasterOnly();
@@ -499,7 +499,7 @@ public long HyperLogLogLength(RedisKey[] keys, CommandFlags flags = CommandFlags
             var cmd = Message.Create(Database, flags, RedisCommand.PFCOUNT, keys);
             if (keys.Length != 0)
             {
-                var features = GetFeatures(Database, keys[0], flags, out server);
+                var features = GetFeatures(keys[0], flags, out server);
                 // technically a write / master-only command until 2.8.18
                 if (server != null && !features.HyperLogLogCountSlaveSafe) cmd.SetMasterOnly();
             }
@@ -508,7 +508,7 @@ public long HyperLogLogLength(RedisKey[] keys, CommandFlags flags = CommandFlags
 
         public Task<long> HyperLogLogLengthAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
         {
-            var features = GetFeatures(Database, key, flags, out ServerEndPoint server);
+            var features = GetFeatures(key, flags, out ServerEndPoint server);
             var cmd = Message.Create(Database, flags, RedisCommand.PFCOUNT, key);
             // technically a write / master-only command until 2.8.18
             if (server != null && !features.HyperLogLogCountSlaveSafe) cmd.SetMasterOnly();
@@ -522,7 +522,7 @@ public Task<long> HyperLogLogLengthAsync(RedisKey[] keys, CommandFlags flags = C
             var cmd = Message.Create(Database, flags, RedisCommand.PFCOUNT, keys);
             if (keys.Length != 0)
             {
-                var features = GetFeatures(Database, keys[0], flags, out server);
+                var features = GetFeatures(keys[0], flags, out server);
                 // technically a write / master-only command until 2.8.18
                 if (server != null && !features.HyperLogLogCountSlaveSafe) cmd.SetMasterOnly();
             }
@@ -567,7 +567,7 @@ public Task<EndPoint> IdentifyEndpointAsync(RedisKey key = default(RedisKey), Co
 
         public bool IsConnected(RedisKey key, CommandFlags flags = CommandFlags.None)
         {
-            var server = multiplexer.SelectServer(Database, RedisCommand.PING, flags, key);
+            var server = multiplexer.SelectServer(RedisCommand.PING, flags, key);
             return server?.IsConnected == true;
         }
 
@@ -611,7 +611,7 @@ public Task<long> KeyDeleteAsync(RedisKey[] keys, CommandFlags flags = CommandFl
 
         private RedisCommand GetDeleteCommand(RedisKey key, CommandFlags flags, out ServerEndPoint server)
         {
-            var features = GetFeatures(Database, key, flags, out server);
+            var features = GetFeatures(key, flags, out server);
             if (server != null && features.Unlink && multiplexer.CommandMap.IsAvailable(RedisCommand.UNLINK))
             {
                 return RedisCommand.UNLINK;
@@ -813,7 +813,7 @@ public Task KeyRestoreAsync(RedisKey key, byte[] value, TimeSpan? expiry = null,
 
         public TimeSpan? KeyTimeToLive(RedisKey key, CommandFlags flags = CommandFlags.None)
         {
-            var features = GetFeatures(Database, key, flags, out ServerEndPoint server);
+            var features = GetFeatures(key, flags, out ServerEndPoint server);
             Message msg;
             if (server != null && features.MillisecondExpiry && multiplexer.CommandMap.IsAvailable(RedisCommand.PTTL))
             {
@@ -826,7 +826,7 @@ public Task KeyRestoreAsync(RedisKey key, byte[] value, TimeSpan? expiry = null,
 
         public Task<TimeSpan?> KeyTimeToLiveAsync(RedisKey key, CommandFlags flags = CommandFlags.None)
         {
-            var features = GetFeatures(Database, key, flags, out ServerEndPoint server);
+            var features = GetFeatures(key, flags, out ServerEndPoint server);
             Message msg;
             if (server != null && features.MillisecondExpiry && multiplexer.CommandMap.IsAvailable(RedisCommand.PTTL))
             {
@@ -2406,7 +2406,7 @@ private Message GetExpiryMessage(RedisKey key, CommandFlags flags, TimeSpan? exp
             long milliseconds = duration.Ticks / TimeSpan.TicksPerMillisecond;
             if ((milliseconds % 1000) != 0)
             {
-                var features = GetFeatures(Database, key, flags, out server);
+                var features = GetFeatures(key, flags, out server);
                 if (server != null && features.MillisecondExpiry && multiplexer.CommandMap.IsAvailable(RedisCommand.PEXPIRE))
                 {
                     return Message.Create(Database, flags, RedisCommand.PEXPIRE, key, milliseconds);
@@ -2437,7 +2437,7 @@ private Message GetExpiryMessage(RedisKey key, CommandFlags flags, DateTime? exp
 
             if ((milliseconds % 1000) != 0)
             {
-                var features = GetFeatures(Database, key, flags, out server);
+                var features = GetFeatures(key, flags, out server);
                 if (server != null && features.MillisecondExpiry && multiplexer.CommandMap.IsAvailable(RedisCommand.PEXPIREAT))
                 {
                     return Message.Create(Database, flags, RedisCommand.PEXPIREAT, key, milliseconds);
@@ -3174,7 +3174,7 @@ private Message GetStringGetWithExpiryMessage(RedisKey key, CommandFlags flags,
             {
                 throw new NotSupportedException("This operation is not possible inside a transaction or batch; please issue separate GetString and KeyTimeToLive requests");
             }
-            var features = GetFeatures(Database, key, flags, out server);
+            var features = GetFeatures(key, flags, out server);
             processor = StringGetWithExpiryProcessor.Default;
             if (server != null && features.MillisecondExpiry && multiplexer.CommandMap.IsAvailable(RedisCommand.PTTL))
             {
@@ -3278,7 +3278,7 @@ private IEnumerable<T> TryScan<T>(RedisKey key, RedisValue pattern, int pageSize
             if (pageSize <= 0) throw new ArgumentOutOfRangeException(nameof(pageSize));
             if (!multiplexer.CommandMap.IsAvailable(command)) return null;
 
-            var features = GetFeatures(Database, key, flags, out ServerEndPoint server);
+            var features = GetFeatures(key, flags, out ServerEndPoint server);
             if (!features.Scan) return null;
 
             if (CursorUtils.IsNil(pattern)) pattern = (byte[])null;

StackExchange.Redis/RedisServer.cs

@@ -583,7 +583,7 @@ internal override T ExecuteSync<T>(Message message, ResultProcessor<T> processor
             return base.ExecuteSync<T>(message, processor, server);
         }
 
-        internal override RedisFeatures GetFeatures(int db, RedisKey key, CommandFlags flags, out ServerEndPoint server)
+        internal override RedisFeatures GetFeatures(RedisKey key, CommandFlags flags, out ServerEndPoint server)
         {
             server = this.server;
             return new RedisFeatures(server.Version);

StackExchange.Redis/RedisSubscriber.cs

@@ -132,7 +132,7 @@ internal bool SubscriberConnected(RedisChannel channel = default(RedisChannel))
             var server = GetSubscribedServer(channel);
             if (server != null) return server.IsConnected;
 
-            server = SelectServer(-1, RedisCommand.SUBSCRIBE, CommandFlags.DemandMaster, default(RedisKey));
+            server = SelectServer(RedisCommand.SUBSCRIBE, CommandFlags.DemandMaster, default(RedisKey));
             return server?.IsConnected == true;
         }
 
@@ -196,7 +196,7 @@ public bool Remove(bool asAsync, Action<RedisChannel, RedisValue> value)
             public Task SubscribeToServer(ConnectionMultiplexer multiplexer, RedisChannel channel, CommandFlags flags, object asyncState, bool internalCall)
             {
                 var cmd = channel.IsPatternBased ? RedisCommand.PSUBSCRIBE : RedisCommand.SUBSCRIBE;
-                var selected = multiplexer.SelectServer(-1, cmd, flags, default(RedisKey));
+                var selected = multiplexer.SelectServer(cmd, flags, default(RedisKey));
 
                 if (selected == null || Interlocked.CompareExchange(ref owner, selected, null) != null) return null;
 
@@ -336,7 +336,7 @@ private Message CreatePingMessage(CommandFlags flags, out ServerEndPoint server)
             server = null;
             if (multiplexer.CommandMap.IsAvailable(RedisCommand.PING))
             {
-                try { usePing = GetFeatures(-1, default, flags, out server).PingOnSubscriber; }
+                try { usePing = GetFeatures(default, flags, out server).PingOnSubscriber; }
                 catch { }
             }
 

StackExchange.Redis/ServerSelectionStrategy.cs

@@ -107,7 +107,7 @@ public ServerEndPoint Select(Message message)
             return Select(slot, message.Command, message.Flags);
         }
 
-        public ServerEndPoint Select(int db, RedisCommand command, RedisKey key, CommandFlags flags)
+        public ServerEndPoint Select(RedisCommand command, RedisKey key, CommandFlags flags)
         {
             int slot = ServerType == ServerType.Cluster ? HashSlot(key) : NoSlot;
             return Select(slot, command, flags);