Working on FT.INFO Command

src/NRedisStack/ResponseParser.cs

@@ -485,6 +485,21 @@ public static TimeSeriesInformation ToTimeSeriesInfo(this RedisResult result)
             lastTimestamp, retentionTime, chunkCount, chunkSize, labels, sourceKey, rules, duplicatePolicy, keySelfName, chunks);
         }
 
+        public static Dictionary<string, RedisValue> ToFtInfoAsDictionary(this RedisResult value)
+        {
+            var res = (RedisResult[])value;
+            var info = new Dictionary<string, RedisValue>();
+            for (int i = 0; i < res.Length; i += 2)
+            {
+                var val = res[i + 1];
+                if (val.Type != ResultType.MultiBulk)
+                {
+                    info.Add((string)res[i], (RedisValue)val);
+                }
+            }
+            return info;
+        }
+
         public static IReadOnlyList<TimeSeriesChunck> ToTimeSeriesChunkArray(this RedisResult result)
         {
             RedisResult[] redisResults = (RedisResult[])result;

src/NRedisStack/Search/DataTypes/InfoResult.cs

@@ -0,0 +1,142 @@
+using System.Collections.Generic;
+using StackExchange.Redis;
+
+namespace NRedisStack.Search.DataTypes
+{
+    public class InfoResult
+    {
+        private readonly Dictionary<string, RedisResult> _all = new Dictionary<string, RedisResult>();
+
+        public string IndexName => GetString("index_name");
+        public Dictionary<string, RedisResult> IndexOption => GetRedisResultDictionary("index_options");
+        public Dictionary<string, RedisResult[]> IndexDefinition => GetRedisResultsDictionary("index_definition");
+
+        public Dictionary<string, RedisResult[]> Attributes => GetRedisResultsDictionary("attributes"); // TODO: check if this is correct
+
+        public long NumDocs => GetLong("num_docs");
+
+        public string MaxDocId => GetString("max_doc_id");
+
+        public long NumTerms => GetLong("num_terms");
+
+        public long NumRecords => GetLong("num_records");
+
+        public double InvertedSzMebibytes => GetDouble("inverted_sz_mb");
+
+        public double VectorIndexSzMebibytes => GetDouble("vector_index_sz_mb"); // TODO: check if double or long
+
+        public double TotalInvertedIndexBlocks => GetDouble("total_inverted_index_blocks");
+
+        // public double InvertedCapOvh => GetDouble("inverted_cap_ovh");
+
+        public double OffsetVectorsSzMebibytes => GetDouble("offset_vectors_sz_mb");
+
+        public double DocTableSizeMebibytes => GetDouble("doc_table_size_mb");
+
+        public double SortableValueSizeMebibytes => GetDouble("sortable_value_size_mb");
+
+        public double KeyTableSizeMebibytes => GetDouble("key_table_size_mb");
+
+        // public double SkipIndexSizeMebibytes => GetDouble("skip_index_size_mb");
+
+        // public double ScoreIndexSizeMebibytes => GetDouble("score_index_size_mb");
+
+        public double RecordsPerDocAvg => GetDouble("records_per_doc_avg");
+
+        public double BytesPerRecordAvg => GetDouble("bytes_per_record_avg");
+
+        public double OffsetsPerTermAvg => GetDouble("offsets_per_term_avg");
+
+        public double OffsetBitsPerRecordAvg => GetDouble("offset_bits_per_record_avg");
+
+        public long HashIndexingFailures => GetLong("hash_indexing_failures");
+
+        public double TotalIndexingTime => GetDouble("total_indexing_time");
+
+        public long Indexing => GetLong("indexing");
+
+        public double PercentIndexed => GetDouble("percent_indexed");
+
+        public long NumberOfUses => GetLong("number_of_uses");
+
+
+        public Dictionary<string, RedisResult> GcStats => GetRedisResultDictionary("gc_stats");
+
+        public Dictionary<string, RedisResult> CursorStats => GetRedisResultDictionary("cursor_stats");
+
+        public InfoResult(RedisResult result)
+        {
+            var results = (RedisResult[])result;
+
+            for (var i = 0; i < results.Length; i += 2)
+            {
+                var key = (string)results[i];
+                var value = results[i + 1];
+
+                _all.Add(key, value);
+            }
+        }
+
+        private string GetString(string key) => _all.TryGetValue(key, out var value) ? (string)value : default;
+
+        private long GetLong(string key) => _all.TryGetValue(key, out var value) ? (long)value : default;
+
+        private double GetDouble(string key)
+        {
+            if (_all.TryGetValue(key, out var value))
+            {
+                if ((string)value == "-nan")
+                {
+                    return default;
+                }
+                else
+                {
+                    return (double)value;
+                }
+            }
+            else
+            {
+                return default;
+            }
+        }
+
+        private Dictionary<string, RedisResult> GetRedisResultDictionary(string key)
+        {
+            if (_all.TryGetValue(key, out var value))
+            {
+                var values = (RedisResult[])value;
+                var result = new Dictionary<string, RedisResult>();
+
+                for (var ii = 0; ii < values.Length; ii += 2)
+                {
+                    result.Add((string)values[ii], values[ii + 1]);
+                }
+
+                return result;
+            }
+            else
+            {
+                return default;
+            }
+        }
+
+        private Dictionary<string, RedisResult[]> GetRedisResultsDictionary(string key)
+        {
+            if (_all.TryGetValue(key, out var value))
+            {
+                var result = new Dictionary<string, RedisResult[]>();
+
+                foreach (RedisResult[] fv in (RedisResult[])value)
+                {
+                    result.Add((string)fv[0], fv);
+                }
+
+                return result;
+            }
+            else
+            {
+                return default;
+            }
+        }
+    }
+}

src/NRedisStack/Search/DataTypes/SearchInformation.cs

@@ -1,34 +1,34 @@
-namespace NRedisStack.Search.DataTypes
-{
-    /// <summary>
-    /// This class represents the response for SEARCH.INFO command.
-    /// This object has Read-only properties and cannot be generated outside a SEARCH.INFO response.
-    /// </summary>
-    public class SearchInformation
-    {
-        // TODO: work on it with someone from Search team
-        // public string IndexName { get; private set; }
-        // public string[] IndexOptions { get; private set; }
-        // public long IndexDefinition { get; private set; }
-        // public long UnmergedNodes { get; private set; }
-        // public double MergedWeight { get; private set; }
-        // public double UnmergedWeight { get; private set; }
+// namespace NRedisStack.Search.DataTypes
+// {
+//     /// <summary>
+//     /// This class represents the response for SEARCH.INFO command.
+//     /// This object has Read-only properties and cannot be generated outside a SEARCH.INFO response.
+//     /// </summary>
+//     public class SearchInformation
+//     {
+//         // TODO: work on it with someone from Search team
+//         // public string IndexName { get; private set; }
+//         // public string[] IndexOptions { get; private set; }
+//         // public long IndexDefinition { get; private set; }
+//         // public long UnmergedNodes { get; private set; }
+//         // public double MergedWeight { get; private set; }
+//         // public double UnmergedWeight { get; private set; }
 
-        // public long TotalCompressions { get; private set; }
+//         // public long TotalCompressions { get; private set; }
 
 
-        // internal SearchInformation(long compression, long capacity, long mergedNodes,
-        //                             long unmergedNodes, double mergedWeight,
-        //                             double unmergedWeight, long totalCompressions)
+//         // internal SearchInformation(long compression, long capacity, long mergedNodes,
+//         //                             long unmergedNodes, double mergedWeight,
+//         //                             double unmergedWeight, long totalCompressions)
 
-        // {
-        //     Compression = compression;
-        //     Capacity = capacity;
-        //     MergedNodes = mergedNodes;
-        //     UnmergedNodes = unmergedNodes;
-        //     MergedWeight = mergedWeight;
-        //     UnmergedWeight = unmergedWeight;
-        //     TotalCompressions = totalCompressions;
-        // }
-    }
-}
+//         // {
+//         //     Compression = compression;
+//         //     Capacity = capacity;
+//         //     MergedNodes = mergedNodes;
+//         //     UnmergedNodes = unmergedNodes;
+//         //     MergedWeight = mergedWeight;
+//         //     UnmergedWeight = unmergedWeight;
+//         //     TotalCompressions = totalCompressions;
+//         // }
+//     }
+// }

src/NRedisStack/Search/SearchCommands.cs

@@ -1,5 +1,6 @@
 using NRedisStack.Literals;
 using NRedisStack.Search;
+using NRedisStack.Search.DataTypes;
 using NRedisStack.Search.FT.CREATE;
 using StackExchange.Redis;
 namespace NRedisStack
@@ -148,11 +149,26 @@ public async Task<bool> AlterAsync(string index, Schema schema, bool skipInitial
             return (await _db.ExecuteAsync(FT.ALTER, args)).OKtoBoolean();
         }
 
-        // TODO: finish this & add summary
-        public RedisResult Info(RedisValue index)
-        {
-            return _db.Execute(FT.INFO, index);
-        }
+        // /// <summary>
+        // /// Return information and statistics on the index.
+        // /// </summary>
+        // /// <param name="key">The name of the index.</param>
+        // /// <returns>Dictionary of key and value with information about the index</returns>
+        // /// <remarks><seealso href="https://redis.io/commands/ft.info"/></remarks>
+        // public Dictionary<string, RedisValue> Info(RedisValue index)
+        // {
+        //     return _db.Execute(FT.INFO, index).ToFtInfoAsDictionary();
+        // }
+
+        /// <summary>
+        /// Return information and statistics on the index.
+        /// </summary>
+        /// <param name="key">The name of the index.</param>
+        /// <returns>Dictionary of key and value with information about the index</returns>
+        /// <remarks><seealso href="https://redis.io/commands/ft.info"/></remarks>
+        public InfoResult Info(RedisValue index) =>
+            new InfoResult(_db.Execute("FT.INFO", index));
+
 
         /// <summary>
         /// Create an index with the given specification.

tests/NRedisStack.Tests/Search/SearchTests.cs

@@ -227,11 +227,12 @@ public void AlterAdd()
         SearchResult res2 = ft.Search(index, new Query("@tags:{tagA}"));
         Assert.Equal(100, res2.TotalResults);
 
-        //TODO: complete this test when I finish the command FT.INFO
-        // var info = ft.Info(index);
-        // Assert.Equal(index, info.get("index_name"));
-        // Assert.Equal("identifier", ((List)((List)info.get("attributes")).get(1)).get(0));
-        // Assert.Equal("attribute", ((List)((List)info.get("attributes")).get(1)).get(2));
+        //TODO: complete this test
+        var info = ft.Info(index);
+        Assert.Equal(index, info.IndexName);
+        //var result = info["attributes"];
+        // Assert.Equal("identifier", (info.Attributes[]);
+        // Assert.Equal("attribute", ((RedisValue[])((RedisValue[])info["attributes"])[1])[2]);
     }
 
     [Fact]
@@ -266,8 +267,8 @@ public async Task AlterAddAsync()
         //TODO: complete this test when I finish the command FT.INFO
         // var info = ft.Info(index);
         // Assert.Equal(index, info.get("index_name"));
-        // Assert.Equal("identifier", ((List)((List)info.get("attributes")).get(1)).get(0));
-        // Assert.Equal("attribute", ((List)((List)info.get("attributes")).get(1)).get(2));
+        // Assert.Equal("identifier", ((RedisValue[])((RedisValue[])info.get("attributes"))[1])[0]);
+        // Assert.Equal("attribute", ((RedisValue[])((RedisValue[])info.get("attributes"))[1])[2]);
     }
 
     [Fact]