add support for Index Definition (#1544)

* add support for Index Definition

* remove nullable

* keep binary compatibility add another constructor

* Mark AddHash as deprecated

* Add basic test

* fix build

* fix build

* Update ClientTest.cs

* Update RediSearchTestBase.cs

* fix type enum ToString()

* remove AddHash test, command is not supported in Search 2.0

* set tests to run in serial

* revert

* add AssemblyInfo.cs

* fix according to code review

* fix build

* ForceReplication during failovers to reduce errors in clustered scenarios

* NRediSearch: flush every test

Fundamentally, JRediSearch is doing this, and bases test assumptions on it. To get back to a decent/matching state, we need to do the same.

* ...and disable parallelization...

* Match RediSearch 2.0 assumptions

See https://github.com/RediSearch/JRediSearch/blob/f1d7e2ed64a18e99b31b3b7fe48bb972c00e3999/src/test/java/io/redisearch/client/ClientTest.java#L403-L408

* Split builds out

* Woops

* Fix bad merge

* do not perform suggestion range validation if the value came from the server

Co-authored-by: Nick Craver <[email protected]>
Co-authored-by: Jordan Rodak <[email protected]>
Co-authored-by: mgravell <[email protected]>

Author: 4 people

src/NRediSearch/Client.cs

@@ -50,19 +50,104 @@ public enum IndexOptions
             KeepTermFrequencies = 16
         }
 
+        public sealed class IndexDefinition
+        {
+            public enum IndexType
+            {
+                /// <summary>
+                /// Used to indicates that the index should follow the keys of type Hash changes
+                /// </summary>
+                Hash
+            }
+
+            internal readonly IndexType _type = IndexType.Hash;
+            internal readonly bool _async; 
+            internal readonly string[] _prefixes;
+            internal readonly string _filter;
+            internal readonly string _languageField;
+            internal readonly string _language;
+            internal readonly string _scoreFiled;
+            internal readonly double _score;
+            internal readonly string _payloadField;
+
+            public IndexDefinition(bool async = false, string[] prefixes = null,
+            string filter = null, string languageField = null, string language = null, 
+            string scoreFiled = null, double score = 1.0, string payloadField = null)
+            {
+                _async = async;
+                _prefixes = prefixes;
+                _filter = filter;
+                _languageField = languageField;
+                _language = language;
+                _scoreFiled = scoreFiled;
+                _score = score;
+                _payloadField = payloadField;
+            }
+
+            internal void SerializeRedisArgs(List<object> args)
+            {
+                args.Add("ON".Literal());
+                args.Add(_type.ToString("g"));
+                if (_async)
+                {
+                    args.Add("ASYNC".Literal());
+                }
+                if (_prefixes?.Length > 0) 
+                {
+                    args.Add("PREFIX".Literal());
+                    args.Add(_prefixes.Length.ToString());
+                    args.AddRange(_prefixes);
+                }
+                if (_filter != null) 
+                {
+                    args.Add("FILTER".Literal());
+                    args.Add(_filter);
+                }                
+                if (_languageField != null) {
+                    args.Add("LANGUAGE_FIELD".Literal());
+                    args.Add(_languageField);      
+                }                
+                if (_language != null) {
+                    args.Add("LANGUAGE".Literal());
+                    args.Add(_language);      
+                }                
+                if (_scoreFiled != null) {
+                    args.Add("SCORE_FIELD".Literal());
+                    args.Add(_scoreFiled);      
+                }                
+                if (_score != 1.0) {
+                    args.Add("SCORE".Literal());
+                    args.Add(_score.ToString());      
+                }
+                if (_payloadField != null) {
+                    args.Add("PAYLOAD_FIELD".Literal());
+                    args.Add(_payloadField);      
+                }
+            }
+
+        }
+
         public sealed class ConfiguredIndexOptions
         {
             // This news up a enum which results in the 0 equivalent.
             // It's not used in the library and I'm guessing this isn't intentional.
             public static IndexOptions Default => new IndexOptions();
 
             private IndexOptions _options;
+            private IndexDefinition _definition;
             private string[] _stopwords;
+
             public ConfiguredIndexOptions(IndexOptions options = IndexOptions.Default)
             {
                 _options = options;
             }
 
+            public ConfiguredIndexOptions(IndexDefinition definition, IndexOptions options = IndexOptions.Default) 
+            : this(options)
+            {
+                _definition = definition;
+            }
+
             /// <summary>
             /// Set a custom stopword list.
             /// </summary>
@@ -84,17 +169,18 @@ public ConfiguredIndexOptions SetNoStopwords()
 
             internal void SerializeRedisArgs(List<object> args)
             {
-                SerializeRedisArgs(_options, args);
-                if (_stopwords != null && _stopwords.Length != 0)
+                SerializeRedisArgs(_options, args, _definition);
+                if (_stopwords?.Length > 0)
                 {
                     args.Add("STOPWORDS".Literal());
                     args.Add(_stopwords.Length.Boxed());
                     args.AddRange(_stopwords);
                 }
             }
 
-            internal static void SerializeRedisArgs(IndexOptions options, List<object> args)
+            internal static void SerializeRedisArgs(IndexOptions options, List<object> args, IndexDefinition definition)
             {
+                definition?.SerializeRedisArgs(args);
                 if ((options & IndexOptions.UseTermOffsets) == 0)
                 {
                     args.Add("NOOFFSETS".Literal());
@@ -453,20 +539,24 @@ public Task<bool> ReplaceDocumentAsync(string docId, Dictionary<string, RedisVal
 
         /// <summary>
         /// Index a document already in redis as a HASH key.
+        /// [Deprecated] Use IDatabase.HashSet instead.
         /// </summary>
         /// <param name="docId">the id of the document in redis. This must match an existing, unindexed HASH key</param>
         /// <param name="score">the document's index score, between 0 and 1</param>
         /// <param name="replace">if set, and the document already exists, we reindex and update it</param>
         /// <returns>true on success</returns>
+        [Obsolete("Use IDatabase.HashSet instead.")]
         public bool AddHash(string docId, double score, bool replace) => AddHash((RedisKey)docId, score, replace);
 
         /// <summary>
         /// Index a document already in redis as a HASH key.
+        /// [Deprecated] Use IDatabase.HashSet instead.
         /// </summary>
         /// <param name="docId">the id of the document in redis. This must match an existing, unindexed HASH key</param>
         /// <param name="score">the document's index score, between 0 and 1</param>
         /// <param name="replace">if set, and the document already exists, we reindex and update it</param>
         /// <returns>true on success</returns>
+        [Obsolete("Use IDatabase.HashSet instead.")]
         public bool AddHash(RedisKey docId, double score, bool replace)
         {
             var args = new List<object> { _boxedIndexName, docId, score };
@@ -479,20 +569,24 @@ public bool AddHash(RedisKey docId, double score, bool replace)
 
         /// <summary>
         /// Index a document already in redis as a HASH key.
+        /// [Deprecated] Use IDatabase.HashSet instead.
         /// </summary>
         /// <param name="docId">the id of the document in redis. This must match an existing, unindexed HASH key</param>
         /// <param name="score">the document's index score, between 0 and 1</param>
         /// <param name="replace">if set, and the document already exists, we reindex and update it</param>
         /// <returns>true on success</returns>
+        [Obsolete("Use IDatabase.HashSet instead.")]
         public Task<bool> AddHashAsync(string docId, double score, bool replace) => AddHashAsync((RedisKey)docId, score, replace);
 
         /// <summary>
         /// Index a document already in redis as a HASH key.
+        /// [Deprecated] Use IDatabase.HashSet instead.
         /// </summary>
         /// <param name="docId">the id of the document in redis. This must match an existing, unindexed HASH key</param>
         /// <param name="score">the document's index score, between 0 and 1</param>
         /// <param name="replace">if set, and the document already exists, we reindex and update it</param>
         /// <returns>true on success</returns>
+        [Obsolete("Use IDatabase.HashSet instead.")]
         public async Task<bool> AddHashAsync(RedisKey docId, double score, bool replace)
         {
             var args = new List<object> { _boxedIndexName, docId, score };
@@ -1250,7 +1344,7 @@ private static Suggestion[] GetSuggestionsNoOptions(RedisResult[] results)
 
             for (var i = 0; i < results.Length; i++)
             {
-                suggestions[i] = Suggestion.Builder.String((string)results[i]).Build();
+                suggestions[i] = Suggestion.Builder.String((string)results[i]).Build(true);
             }
 
             return suggestions;
@@ -1268,7 +1362,7 @@ private static Suggestion[] GetSuggestionsWithPayloadAndScores(RedisResult[] res
                 suggestion.Score((double)results[i - 2]);
                 suggestion.Payload((string)results[i - 1]);
 
-                suggestions[(i / 3) - 1] = suggestion.Build();
+                suggestions[(i / 3) - 1] = suggestion.Build(true);
             }
 
             return suggestions;
@@ -1285,7 +1379,7 @@ private static Suggestion[] GetSuggestionsWithPayload(RedisResult[] results)
                 suggestion.String((string)results[i - 2]);
                 suggestion.Payload((string)results[i - 1]);
 
-                suggestions[(i / 2) - 1] = suggestion.Build();
+                suggestions[(i / 2) - 1] = suggestion.Build(true);
             }
 
             return suggestions;
@@ -1302,7 +1396,7 @@ private static Suggestion[] GetSuggestionsWithScores(RedisResult[] results)
                 suggestion.String((string)results[i - 2]);
                 suggestion.Score((double)results[i - 1]);
 
-                suggestions[(i / 2) - 1] = suggestion.Build();
+                suggestions[(i / 2) - 1] = suggestion.Build(true);
             }
 
             return suggestions;

src/NRediSearch/Suggestion.cs

@@ -89,10 +89,12 @@ public SuggestionBuilder Payload(string payload)
                 return this;
             }
 
-            public Suggestion Build()
+            public Suggestion Build() => Build(false);
+
+            internal Suggestion Build(bool fromServer)
             {
                 bool isStringMissing = _string == null;
-                bool isScoreOutOfRange = (_score < 0.0 || _score > 1.0);
+                bool isScoreOutOfRange = !fromServer && (_score < 0.0 || _score > 1.0);
 
                 if (isStringMissing || isScoreOutOfRange)
                 {

tests/NRediSearch.Test/AssemblyInfo.cs

@@ -0,0 +1,15 @@
+using System;
+using Xunit;
+
+[assembly: CollectionBehavior(CollectionBehavior.CollectionPerAssembly, DisableTestParallelization = true)]
+
+namespace NRediSearch.Test
+{
+
+    public class AssemblyInfo
+    {
+        public AssemblyInfo()
+        {
+        }
+    }
+}

tests/NRediSearch.Test/ClientTests/ClientTest.cs

@@ -290,19 +290,23 @@ public void TestSortQueryFlags()
         }
 
         [Fact]
-        public void TestAddHash()
+        public void TestIndexDefinition()
         {
             Client cl = GetClient();
-
             Schema sc = new Schema().AddTextField("title", 1.0);
-            Assert.True(cl.CreateIndex(sc, new ConfiguredIndexOptions()));
+            ConfiguredIndexOptions options = new ConfiguredIndexOptions(
+                new IndexDefinition( prefixes: new string[]{cl.IndexName}));
+            Assert.True(cl.CreateIndex(sc, options));
+
             RedisKey hashKey = (string)cl.IndexName + ":foo";
             Db.KeyDelete(hashKey);
             Db.HashSet(hashKey, "title", "hello world");
 
             try
             {
+#pragma warning disable 0618
                 Assert.True(cl.AddHash(hashKey, 1, false));
+#pragma warning restore 0618
             }
             catch (RedisServerException e)
             {