Implement vector search command with enhanced limit and offset handling, including error responses for invalid syntax

miserix13 · miserix13 · commit fe5a0bc97332 · 2026-02-19T09:10:42.000-06:00
diff --git a/Dredis.Tests/DredisCommandHandlerTests.cs b/Dredis.Tests/DredisCommandHandlerTests.cs
@@ -1690,6 +1690,132 @@ public async Task Vector_Search_InvalidOffset_ReturnsError()
             }
         }
 
+        [Fact]
+        public async Task Vector_Search_LimitSyntax_WorksWithoutPositionalTopK()
+        {
+            var store = new InMemoryKeyValueStore();
+            var channel = new EmbeddedChannel(new DredisCommandHandler(store));
+
+            try
+            {
+                channel.WriteInbound(Command("VSET", "emb:a", "1", "0"));
+                channel.RunPendingTasks();
+                _ = ReadOutbound(channel);
+
+                channel.WriteInbound(Command("VSET", "emb:b", "0.8", "0.2"));
+                channel.RunPendingTasks();
+                _ = ReadOutbound(channel);
+
+                channel.WriteInbound(Command("VSEARCH", "emb:", "COSINE", "LIMIT", "1", "1", "0"));
+                channel.RunPendingTasks();
+
+                var response = ReadOutbound(channel);
+                var array = Assert.IsType<ArrayRedisMessage>(response);
+                Assert.Equal(2, array.Children.Count);
+                Assert.Equal("emb:a", GetBulkString(Assert.IsType<FullBulkStringRedisMessage>(array.Children[0])));
+            }
+            finally
+            {
+                await channel.CloseAsync();
+            }
+        }
+
+        [Fact]
+        public async Task Vector_Search_LimitMissing_ReturnsError()
+        {
+            var store = new InMemoryKeyValueStore();
+            var channel = new EmbeddedChannel(new DredisCommandHandler(store));
+
+            try
+            {
+                channel.WriteInbound(Command("VSEARCH", "emb:", "COSINE", "1", "0"));
+                channel.RunPendingTasks();
+
+                var response = ReadOutbound(channel);
+                var error = Assert.IsType<ErrorRedisMessage>(response);
+                Assert.Equal("ERR LIMIT is required", error.Content);
+            }
+            finally
+            {
+                await channel.CloseAsync();
+            }
+        }
+
+        [Fact]
+        public async Task Vector_Search_OffsetBeforeLimit_ReturnsSyntaxError()
+        {
+            var store = new InMemoryKeyValueStore();
+            var channel = new EmbeddedChannel(new DredisCommandHandler(store));
+
+            try
+            {
+                channel.WriteInbound(Command("VSET", "emb:a", "1", "0"));
+                channel.RunPendingTasks();
+                _ = ReadOutbound(channel);
+
+                channel.WriteInbound(Command("VSEARCH", "emb:", "COSINE", "OFFSET", "1", "LIMIT", "1", "1", "0"));
+                channel.RunPendingTasks();
+
+                var response = ReadOutbound(channel);
+                var error = Assert.IsType<ErrorRedisMessage>(response);
+                Assert.Equal("ERR LIMIT is required", error.Content);
+            }
+            finally
+            {
+                await channel.CloseAsync();
+            }
+        }
+
+        [Fact]
+        public async Task Vector_Search_LimitInPositionalForm_ReturnsSyntaxError()
+        {
+            var store = new InMemoryKeyValueStore();
+            var channel = new EmbeddedChannel(new DredisCommandHandler(store));
+
+            try
+            {
+                channel.WriteInbound(Command("VSET", "emb:a", "1", "0"));
+                channel.RunPendingTasks();
+                _ = ReadOutbound(channel);
+
+                channel.WriteInbound(Command("VSEARCH", "emb:", "2", "COSINE", "LIMIT", "1", "1", "0"));
+                channel.RunPendingTasks();
+
+                var response = ReadOutbound(channel);
+                var error = Assert.IsType<ErrorRedisMessage>(response);
+                Assert.Equal("ERR syntax error", error.Content);
+            }
+            finally
+            {
+                await channel.CloseAsync();
+            }
+        }
+
+        [Fact]
+        public async Task Vector_Search_DuplicateOffset_ReturnsSyntaxError()
+        {
+            var store = new InMemoryKeyValueStore();
+            var channel = new EmbeddedChannel(new DredisCommandHandler(store));
+
+            try
+            {
+                channel.WriteInbound(Command("VSET", "emb:a", "1", "0"));
+                channel.RunPendingTasks();
+                _ = ReadOutbound(channel);
+
+                channel.WriteInbound(Command("VSEARCH", "emb:", "2", "COSINE", "OFFSET", "0", "OFFSET", "1", "1", "0"));
+                channel.RunPendingTasks();
+
+                var response = ReadOutbound(channel);
+                var error = Assert.IsType<ErrorRedisMessage>(response);
+                Assert.Equal("ERR syntax error", error.Content);
+            }
+            finally
+            {
+                await channel.CloseAsync();
+            }
+        }
+
         [Fact]
         public async Task Publish_NoSubscribers_ReturnsZero()
         {
diff --git a/DredisCommandHandler.cs b/DredisCommandHandler.cs
@@ -2343,48 +2343,130 @@ private async Task HandleVectorSearchAsync(
             IChannelHandlerContext ctx,
             IList<IRedisMessage> args)
         {
-            if (args.Count < 6)
+            if (args.Count < 5)
             {
                 WriteError(ctx, "ERR wrong number of arguments for 'vsearch' command");
                 return;
             }
 
-            if (!TryGetString(args[1], out var keyPrefix) ||
-                !TryGetString(args[2], out var topKText) ||
-                !TryGetString(args[3], out var metric))
+            if (!TryGetString(args[1], out var keyPrefix))
             {
                 WriteError(ctx, "ERR null bulk string");
                 return;
             }
 
-            if (!int.TryParse(topKText, out var topK) || topK <= 0)
+            if (!TryGetString(args[2], out var token2))
             {
-                WriteError(ctx, "ERR value is not an integer or out of range");
+                WriteError(ctx, "ERR null bulk string");
                 return;
             }
 
+            int topK;
             int offset = 0;
-            int vectorStartIndex = 4;
-            if (args.Count >= 7 && TryGetString(args[4], out var offsetToken) &&
-                string.Equals(offsetToken, "OFFSET", StringComparison.OrdinalIgnoreCase))
+            string metric;
+            int index;
+            bool positionalForm;
+
+            if (int.TryParse(token2, out var positionalTopK))
+            {
+                if (positionalTopK <= 0)
+                {
+                    WriteError(ctx, "ERR value is not an integer or out of range");
+                    return;
+                }
+
+                topK = positionalTopK;
+                if (!TryGetString(args[3], out metric))
+                {
+                    WriteError(ctx, "ERR null bulk string");
+                    return;
+                }
+
+                index = 4;
+                positionalForm = true;
+            }
+            else
+            {
+                metric = token2;
+                topK = -1;
+                index = 3;
+                positionalForm = false;
+            }
+
+            if (positionalForm)
+            {
+                if (index + 1 < args.Count && TryGetString(args[index], out var option))
+                {
+                    if (option.Equals("LIMIT", StringComparison.OrdinalIgnoreCase))
+                    {
+                        WriteError(ctx, "ERR syntax error");
+                        return;
+                    }
+
+                    if (option.Equals("OFFSET", StringComparison.OrdinalIgnoreCase))
+                    {
+                        if (!TryGetString(args[index + 1], out var offsetText) || !int.TryParse(offsetText, out offset) || offset < 0)
+                        {
+                            WriteError(ctx, "ERR value is not an integer or out of range");
+                            return;
+                        }
+
+                        index += 2;
+                    }
+                }
+            }
+            else
             {
-                if (!TryGetString(args[5], out var offsetText) || !int.TryParse(offsetText, out offset) || offset < 0)
+                if (args.Count < 4)
+                {
+                    WriteError(ctx, "ERR wrong number of arguments for 'vsearch' command");
+                    return;
+                }
+
+                if (!TryGetString(args[index], out var limitToken) ||
+                    !limitToken.Equals("LIMIT", StringComparison.OrdinalIgnoreCase))
+                {
+                    WriteError(ctx, "ERR LIMIT is required");
+                    return;
+                }
+
+                if (!TryGetString(args[index + 1], out var limitText) || !int.TryParse(limitText, out topK) || topK <= 0)
                 {
                     WriteError(ctx, "ERR value is not an integer or out of range");
                     return;
                 }
 
-                vectorStartIndex = 6;
+                index += 2;
+
+                if (index + 1 < args.Count && TryGetString(args[index], out var offsetToken) &&
+                    offsetToken.Equals("OFFSET", StringComparison.OrdinalIgnoreCase))
+                {
+                    if (!TryGetString(args[index + 1], out var offsetText) || !int.TryParse(offsetText, out offset) || offset < 0)
+                    {
+                        WriteError(ctx, "ERR value is not an integer or out of range");
+                        return;
+                    }
+
+                    index += 2;
+                }
+            }
+
+            if (index < args.Count && TryGetString(args[index], out var unexpectedToken) &&
+                (unexpectedToken.Equals("LIMIT", StringComparison.OrdinalIgnoreCase) ||
+                 unexpectedToken.Equals("OFFSET", StringComparison.OrdinalIgnoreCase)))
+            {
+                WriteError(ctx, "ERR syntax error");
+                return;
             }
 
-            if (args.Count <= vectorStartIndex)
+            if (args.Count <= index)
             {
                 WriteError(ctx, "ERR wrong number of arguments for 'vsearch' command");
                 return;
             }
 
-            var queryVector = new double[args.Count - vectorStartIndex];
-            for (int i = vectorStartIndex; i < args.Count; i++)
+            var queryVector = new double[args.Count - index];
+            for (int i = index; i < args.Count; i++)
             {
                 if (!TryGetString(args[i], out var valueText) ||
                     !double.TryParse(valueText, NumberStyles.Float, CultureInfo.InvariantCulture, out var value) ||
@@ -2395,7 +2477,7 @@ private async Task HandleVectorSearchAsync(
                     return;
                 }
 
-                queryVector[i - vectorStartIndex] = value;
+                queryVector[i - index] = value;
             }
 
             var result = await _store.VectorSearchAsync(keyPrefix, topK, offset, metric, queryVector).ConfigureAwait(false);
diff --git a/README.md b/README.md
@@ -56,7 +56,9 @@ Notes:
 - `JSON.ARRREM` removes an element at the specified index from the array (or last element if no index provided).
 - `JSON.ARRTRIM` trims the array at the specified path to the specified range.
 - `JSON.MGET` retrieves JSON values from multiple keys at the specified path.
-- `VSEARCH` supports optional paging via `OFFSET <n>` before query vector components.
+- `VSEARCH` supports paging/options via `LIMIT <n>` and optional `OFFSET <n>` before query vector components.
+- `VSEARCH` is backward-compatible with positional top-k form: `VSEARCH prefix topK metric ...`.
+- `VSEARCH` strict option order: metric form must be `VSEARCH prefix metric LIMIT n [OFFSET n] ...`; positional form supports only optional `OFFSET`.
 
 ## Feature matrix
 
