Add Redis Search Commands

src/NRedisStack/ResponseParser.cs

@@ -485,6 +485,33 @@ 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 Dictionary<string, string> ToConfigDictionary(this RedisResult value)
+        {
+            var res = (RedisResult[])value;
+            var dict = new Dictionary<string, string>();
+            foreach (var pair in res)
+            {
+                var arr = (RedisResult[])pair;
+                dict.Add(arr[0].ToString(), arr[1].ToString());
+            }
+            return dict;
+        }
+
         public static IReadOnlyList<TimeSeriesChunck> ToTimeSeriesChunkArray(this RedisResult result)
         {
             RedisResult[] redisResults = (RedisResult[])result;

src/NRedisStack/Search/AggregationRequest.cs

@@ -0,0 +1,217 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+// using NRediSearch.Aggregation.Reducers;
+using StackExchange.Redis;
+
+namespace NRedisStack.Search.Aggregation
+{
+    public class AggregationRequest
+    {
+        private List<object> args = new List<object>(); // Check if Readonly
+        private bool isWithCursor = false;
+
+        public AggregationRequest(string query)
+        {
+            args.Add(query);
+        }
+
+        public AggregationRequest() : this("*") { }
+
+        // public AggregationRequest load(params string[] fields)
+        // {
+        //     return load(FieldName.Convert(fields));
+        // }
+
+        public AggregationRequest Load(params FieldName[] fields)
+        {
+            args.Add("LOAD");
+            int loadCountIndex = args.Count();
+            args.Add(null);
+            int loadCount = 0;
+            foreach (FieldName fn in fields)
+            {
+                loadCount += fn.AddCommandArguments(args);
+            }
+            args.Insert(loadCountIndex, loadCount.ToString());
+            return this;
+        }
+
+        public AggregationRequest LoadAll()
+        {
+            args.Add("LOAD");
+            args.Add("*");
+            return this;
+        }
+
+        public AggregationRequest Limit(int offset, int count)
+        {
+            Limit limit = new Limit(offset, count);
+            limit.SerializeRedisArgs(args);
+            return this;
+        }
+
+        public AggregationRequest Limit(int count)
+        {
+            return Limit(0, count);
+        }
+
+        public AggregationRequest SortBy(params SortedField[] Fields)
+        {
+            args.Add("SORTBY");
+            args.Add(Fields.Length * 2);
+            foreach (SortedField field in Fields)
+            {
+                args.Add(field.FieldName);
+                args.Add(field.Order);
+            }
+
+            return this;
+        }
+
+        public AggregationRequest SortBy(int max, params SortedField[] Fields)
+        {
+            SortBy(Fields);
+            if (max > 0)
+            {
+                args.Add("MAX");
+                args.Add(max);
+            }
+            return this;
+        }
+
+        public AggregationRequest SortByAsc(string field)
+        {
+            return SortBy(SortedField.Asc(field));
+        }
+
+        public AggregationRequest SortByDesc(string field)
+        {
+            return SortBy(SortedField.Desc(field));
+        }
+
+        public AggregationRequest Apply(string projection, string alias)
+        {
+            args.Add("APPLY");
+            args.Add(projection);
+            args.Add("AS");
+            args.Add(alias);
+            return this;
+        }
+
+        public AggregationRequest GroupBy(IList<string> fields, IList<Reducer> reducers)
+        {
+            // string[] fieldsArr = new string[fields.size()];
+            Group g = new Group(fields);
+            foreach (Reducer r in reducers)
+            {
+                g.Reduce(r);
+            }
+            GroupBy(g);
+            return this;
+        }
+
+        public AggregationRequest GroupBy(string field, params Reducer[] reducers)
+        {
+            return GroupBy(new string[] { field }, reducers);
+        }
+
+        public AggregationRequest GroupBy(Group group)
+        {
+            args.Add("GROUPBY");
+            group.SerializeRedisArgs(args);
+            return this;
+        }
+
+        public AggregationRequest Filter(string expression)
+        {
+            args.Add("FILTER");
+            args.Add(expression);
+            return this;
+        }
+
+        public AggregationRequest Cursor(int count, long maxIdle)
+        {
+            isWithCursor = true;
+            if (count > 0)
+            {
+                args.Add("WITHCURSOR");
+                args.Add("COUNT");
+                args.Add(count);
+                if (maxIdle < long.MaxValue && maxIdle >= 0)
+                {
+                    args.Add("MAXIDLE");
+                    args.Add(maxIdle);
+                }
+            }
+            return this;
+        }
+
+        public AggregationRequest Verbatim()
+        {
+            args.Add("VERBATIM");
+            return this;
+        }
+
+        public AggregationRequest Timeout(long timeout)
+        {
+            if (timeout >= 0)
+            {
+                args.Add("TIMEOUT");
+                args.Add(timeout);
+            }
+            return this;
+        }
+
+        public AggregationRequest Params(Dictionary<string, object> nameValue)
+        {
+            if (nameValue.Count >= 1)
+            {
+                args.Add("PARAMS");
+                args.Add(nameValue.Count * 2);
+                foreach (var entry in nameValue)
+                {
+                    args.Add(entry.Key);
+                    args.Add(entry.Value);
+                }
+            }
+
+            return this;
+        }
+
+        public AggregationRequest Dialect(int dialect)
+        {
+            args.Add("DIALECT");
+            args.Add(dialect);
+            return this;
+        }
+
+        public List<object> GetArgs()
+        {
+            return args;
+        }
+
+        public void SerializeRedisArgs(List<object> redisArgs)
+        {
+            foreach (var s in GetArgs())
+            {
+                redisArgs.Add(s);
+            }
+        }
+
+        // public string getArgsstring()
+        // {
+        //     StringBuilder sj = new StringBuilder(" ");
+        //     foreach (var s in GetArgs())
+        //     {
+        //         sj.Add(s.ToString());
+        //     }
+        //     return sj.tostring();
+        // }
+
+        public bool IsWithCursor()
+        {
+            return isWithCursor;
+        }
+    }
+}

src/NRedisStack/Search/AggregationResult.cs

@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using StackExchange.Redis;
+
+namespace NRedisStack.Search.Aggregation
+{
+    public sealed class AggregationResult
+    {
+        public long TotalResults { get; }
+        private readonly Dictionary<string, RedisValue>[] _results;
+        public long CursorId { get; }
+
+
+        internal AggregationResult(RedisResult result, long cursorId = -1)
+        {
+            var arr = (RedisResult[])result;
+
+            // the first element is always the number of results
+            TotalResults = (long)arr[0];
+
+            _results = new Dictionary<string, RedisValue>[arr.Length - 1];
+            for (int i = 1; i < arr.Length; i++)
+            {
+                var raw = (RedisResult[])arr[i];
+                var cur = new Dictionary<string, RedisValue>();
+                for (int j = 0; j < raw.Length;)
+                {
+                    var key = (string)raw[j++];
+                    var val = raw[j++];
+                    if (val.Type != ResultType.MultiBulk)
+                        cur.Add(key, (RedisValue)val);
+                }
+                _results[i - 1] = cur;
+            }
+
+            CursorId = cursorId;
+        }
+        public IReadOnlyList<Dictionary<string, RedisValue>> GetResults() => _results;
+
+        public Dictionary<string, RedisValue> this[int index]
+            => index >= _results.Length ? null : _results[index];
+
+        public Row GetRow(int index)
+        {
+            if (index >= _results.Length) return default;
+            return new Row(_results[index]);
+        }
+    }
+}