parse search results correctly

Author: mgravell

src/NRedisStack/PublicAPI/PublicAPI.Unshipped.txt

@@ -60,9 +60,8 @@ static NRedisStack.Search.Parameters.From<T>(T obj) -> System.Collections.Generi
 [NRS001]NRedisStack.Search.HybridSearchQuery.VectorSearchConfig.WithVectorData(NRedisStack.Search.VectorData! vectorData) -> NRedisStack.Search.HybridSearchQuery.VectorSearchConfig
 [NRS001]NRedisStack.Search.HybridSearchResult
 [NRS001]NRedisStack.Search.HybridSearchResult.ExecutionTime.get -> System.TimeSpan
-[NRS001]NRedisStack.Search.HybridSearchResult.Results.get -> System.Collections.Generic.IReadOnlyDictionary<string!, object!>![]!
+[NRS001]NRedisStack.Search.HybridSearchResult.Results.get -> NRedisStack.Search.Document![]!
 [NRS001]NRedisStack.Search.HybridSearchResult.TotalResults.get -> long
-[NRS001]NRedisStack.Search.HybridSearchResult.Warnings.get -> string![]!
 [NRS001]NRedisStack.Search.Scorer
 [NRS001]NRedisStack.Search.VectorData
 [NRS001]NRedisStack.Search.VectorSearchMethod

src/NRedisStack/Search/Document.cs

@@ -50,6 +50,54 @@ public static Document Load(string id, double score, byte[]? payload, RedisValue
         return ret;
     }
 
+    internal static Document Load(RedisResult src) // used from HybridSearch
+    {
+        // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
+        if (src is null || src.IsNull || src.Length < 0) return null!;
+
+        var fields = src.ToArray();
+        string id = "";
+        double score = double.NaN;
+        var fieldCount = fields.Length / 2;
+        for (int i = 0; i < fieldCount; i++)
+        {
+            var key = fields[2 * i];
+            if (key.Resp2Type == ResultType.BulkString && !key.IsNull)
+            {
+                var blob = (byte[])key!;
+                switch (blob.Length)
+                {
+                    case 5 when "__key"u8.SequenceEqual(blob):
+                        id = fields[(2 * i) + 1].ToString();
+                        break;
+                    case 7 when "__score"u8.SequenceEqual(blob):
+                        score = (double)fields[(2 * i) + 1];
+                        break;
+                }
+            }
+        }
+        Document doc = new(id, score, null);
+        for (int i = 0; i < fieldCount; i++)
+        {
+            var key = fields[2 * i];
+            if (key.Resp2Type == ResultType.BulkString && !key.IsNull)
+            {
+                var blob = (byte[])key!;
+                switch (blob.Length)
+                {
+                    case 5 when "__key"u8.SequenceEqual(blob):
+                    case 7 when "__score"u8.SequenceEqual(blob):
+                        break; // skip, already parsed
+                    default:
+                        doc[key.ToString()] = (RedisValue)fields[(2 * i) + 1];
+                        break;
+                }
+            }
+        }
+
+        return doc;
+    }
+
     public static Document Load(string id, double score, byte[]? payload, RedisValue[]? fields, string[]? scoreExplained)
     {
         Document ret = Load(id, score, payload, fields);

src/NRedisStack/Search/HybridSearchQuery.cs

@@ -27,6 +27,7 @@ public static class Fields
         /// The score from the query. 
         /// </summary>
         public const string Score = "@__score";
+
         // ReSharper restore InconsistentNaming
     }
     private bool _frozen;

src/NRedisStack/Search/HybridSearchResult.cs

@@ -31,6 +31,7 @@ internal static HybridSearchResult Parse(RedisResult? result)
                             case ResultKey.ExecutionTime:
                                 obj.ExecutionTime = TimeSpan.FromSeconds((double)value);
                                 break;
+                            /* // defer Warnings until we've seen examples
                             case ResultKey.Warnings when value.Length > 0:
                                 var warnings = new string[value.Length];
                                 for (int j = 0; j < value.Length; j++)
@@ -39,14 +40,9 @@ internal static HybridSearchResult Parse(RedisResult? result)
                                 }
                                 obj.Warnings = warnings;
                                 break;
+                                */
                             case ResultKey.Results when value.Length > 0:
-                                var rows = new IReadOnlyDictionary<string, object>[value.Length];
-                                for (int j = 0; j < value.Length; j++)
-                                {
-                                    rows[j] = ParseRow(value[j]);
-                                }
-
-                                obj.Results = rows;
+                                obj._rawResults = value.ToArray();
                                 break;
                         }
                     }
@@ -113,11 +109,37 @@ private enum ResultKey
         Results,
     }
 
+    /// <summary>
+    /// The number of records matched.
+    /// </summary>
     public long TotalResults { get; private set; } = -1; // initialize to -1 to indicate not set
 
+    /// <summary>
+    /// The time taken to execute this query.
+    /// </summary>
     public TimeSpan ExecutionTime { get; private set; }
 
-    public string[] Warnings { get; private set; } = [];
+    // not exposing this until I've seen it being used
+    internal string[] Warnings { get; private set; } = [];
+
+    private RedisResult[] _rawResults = [];
+    private Document[]? _docResults;
+    
+    /// <summary>
+    /// Obtain the results as <see cref="Document"/> entries.
+    /// </summary>
+    public Document[] Results => _docResults ??= ParseDocResults();
 
-    public IReadOnlyDictionary<string, object>[] Results { get; private set; } = [];
+    private Document[] ParseDocResults()
+    {
+        var raw = _rawResults;
+        if (raw.Length == 0) return [];
+        Document[] docs = new Document[raw.Length];
+        for (int i = 0 ; i <  raw.Length ; i ++)
+        {
+            docs[i] = Document.Load(raw[i]);
+        }
+
+        return docs;
+    }
 }

tests/NRedisStack.Tests/Search/HybridSearchIntegrationTests.cs

@@ -1,4 +1,5 @@
 using System.Buffers;
+using System.Data;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -113,7 +114,17 @@ public async Task TestSearch(string endpointId)
         Assert.Equal(10, result.TotalResults);
         Assert.NotEqual(TimeSpan.Zero, result.ExecutionTime);
         Assert.Empty(result.Warnings);
+        Assert.Same(result.Results, result.Results); // check this is not allocating each time
         Assert.Equal(10, result.Results.Length);
+        foreach (var row in result.Results)
+        {
+            Assert.NotNull(row.Id);
+            Assert.NotEqual("", row.Id);
+            Assert.False(double.IsNaN(row.Score));
+            var text1 = (string)row["text1"]!;
+            Assert.False(string.IsNullOrWhiteSpace(text1));
+            Log($"{row.Id}, {row.Score}, {text1}");
+        }
     }
 
     private void WriteArgs(string indexName, HybridSearchQuery query, IReadOnlyDictionary<string, object>? parameters = null)
@@ -146,7 +157,7 @@ private void WriteArgs(string indexName, HybridSearchQuery query, IReadOnlyDicti
                 sb.Append(arg);
             }
         }
-        log.WriteLine(sb.ToString());
+        Log(sb.ToString());
 
         ArrayPool<byte>.Shared.Return(scratch);