[Compatibility] Added NOVALUE option for HSCAN (#701)

Vijay-Nirmal · badrishc · web-flow · commit 7e29c3a9988a · 2024-10-13T10:49:27.000-07:00
* Added NOVALUE option for HSCAN

* Review comment fix

* Fixed test case faliure

---------

Co-authored-by: Badrish Chandramouli &lt;badrishc@microsoft.com&gt;
diff --git a/Directory.Packages.props b/Directory.Packages.props
@@ -21,7 +21,7 @@
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.11.0" />
     <PackageVersion Include="Microsoft.IdentityModel.Protocols.OpenIdConnect" Version="8.0.1" />
     <PackageVersion Include="Microsoft.IdentityModel.Validators" Version="8.0.1" />
-    <PackageVersion Include="StackExchange.Redis" Version="2.8.0" />
+    <PackageVersion Include="StackExchange.Redis" Version="2.8.16" />
     <PackageVersion Include="System.IdentityModel.Tokens.Jwt" Version="8.0.1" />
     <PackageVersion Include="System.Interactive.Async" Version="6.0.1" />
     <PackageVersion Include="System.Text.Json" Version="8.0.5" />
diff --git a/libs/server/Custom/CustomObjectBase.cs b/libs/server/Custom/CustomObjectBase.cs
@@ -78,7 +78,7 @@ public sealed override unsafe bool Operate(ref ObjectInput input, ref SpanByteAn
                 // Scan Command
                 case RespCommand.COSCAN:
                     if (ObjectUtils.ReadScanInput(ref input, ref output, out var cursorInput, out var pattern,
-                            out var patternLength, out var limitCount, out var error))
+                            out var patternLength, out var limitCount, out bool _, out var error))
                     {
                         Scan(cursorInput, out var items, out var cursorOutput, count: limitCount, pattern: pattern,
                             patternLength: patternLength);
diff --git a/libs/server/Objects/Hash/HashObject.cs b/libs/server/Objects/Hash/HashObject.cs
@@ -172,10 +172,10 @@ public override unsafe bool Operate(ref ObjectInput input, ref SpanByteAndMemory
                         break;
                     case HashOperation.HSCAN:
                         if (ObjectUtils.ReadScanInput(ref input, ref output, out var cursorInput, out var pattern,
-                                out var patternLength, out var limitCount, out var error))
+                                out var patternLength, out var limitCount, out bool isNoValue, out var error))
                         {
                             Scan(cursorInput, out var items, out var cursorOutput, count: limitCount, pattern: pattern,
-                                patternLength: patternLength);
+                                patternLength: patternLength, isNoValue);
                             ObjectUtils.WriteScanOutput(items, cursorOutput, ref output);
                         }
                         else
@@ -203,7 +203,7 @@ private void UpdateSize(ReadOnlySpan<byte> key, ReadOnlySpan<byte> value, bool a
         }
 
         /// <inheritdoc />
-        public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0)
+        public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0, bool isNoValue = false)
         {
             cursor = start;
             items = new List<byte[]>();
@@ -215,7 +215,7 @@ public override unsafe void Scan(long start, out List<byte[]> items, out long cu
             }
 
             // Hashset has key and value, so count is multiplied by 2
-            count *= 2;
+            count = isNoValue ? count : count * 2;
             int index = 0;
             foreach (var item in hash)
             {
@@ -228,7 +228,10 @@ public override unsafe void Scan(long start, out List<byte[]> items, out long cu
                 if (patternLength == 0)
                 {
                     items.Add(item.Key);
-                    items.Add(item.Value);
+                    if (!isNoValue)
+                    {
+                        items.Add(item.Value);
+                    }
                 }
                 else
                 {
@@ -237,7 +240,10 @@ public override unsafe void Scan(long start, out List<byte[]> items, out long cu
                         if (GlobUtils.Match(pattern, patternLength, keyPtr, item.Key.Length))
                         {
                             items.Add(item.Key);
-                            items.Add(item.Value);
+                            if (!isNoValue)
+                            {
+                                items.Add(item.Value);
+                            }
                         }
                     }
                 }
diff --git a/libs/server/Objects/List/ListObject.cs b/libs/server/Objects/List/ListObject.cs
@@ -203,7 +203,7 @@ internal void UpdateSize(byte[] item, bool add = true)
         }
 
         /// <inheritdoc />
-        public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0)
+        public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0, bool isNoValue = false)
         {
             throw new NotImplementedException("For scan items in a list use LRANGE command");
         }
diff --git a/libs/server/Objects/ObjectUtils.cs b/libs/server/Objects/ObjectUtils.cs
@@ -49,7 +49,7 @@ public static unsafe void ReallocateOutput(ref SpanByteAndMemory output, ref boo
         /// <param name="error"></param>
         /// <returns></returns>
         public static unsafe bool ReadScanInput(ref ObjectInput input, ref SpanByteAndMemory output,
-            out int cursorInput, out byte* pattern, out int patternLength, out int countInInput, out ReadOnlySpan<byte> error)
+            out int cursorInput, out byte* pattern, out int patternLength, out int countInInput, out bool isNoValue, out ReadOnlySpan<byte> error)
         {
             var currTokenIdx = input.parseStateStartIdx;
 
@@ -66,6 +66,7 @@ public static unsafe bool ReadScanInput(ref ObjectInput input, ref SpanByteAndMe
             countInInput = 10;
 
             error = default;
+            isNoValue = false;
 
             while (currTokenIdx < input.parseState.Count)
             {
@@ -90,6 +91,10 @@ public static unsafe bool ReadScanInput(ref ObjectInput input, ref SpanByteAndMe
                     if (countInInput > limitCountInOutput)
                         countInInput = limitCountInOutput;
                 }
+                else if (sbParam.SequenceEqual(CmdStrings.NOVALUES) || sbParam.SequenceEqual(CmdStrings.novalues))
+                {
+                    isNoValue = true;
+                }
             }
 
             return true;
diff --git a/libs/server/Objects/Set/SetObject.cs b/libs/server/Objects/Set/SetObject.cs
@@ -143,7 +143,7 @@ public override unsafe bool Operate(ref ObjectInput input, ref SpanByteAndMemory
                         break;
                     case SetOperation.SSCAN:
                         if (ObjectUtils.ReadScanInput(ref input, ref output, out var cursorInput, out var pattern,
-                                out var patternLength, out var limitCount, out var error))
+                                out var patternLength, out var limitCount, out bool _, out var error))
                         {
                             Scan(cursorInput, out var items, out var cursorOutput, count: limitCount, pattern: pattern,
                                 patternLength: patternLength);
@@ -172,7 +172,7 @@ internal void UpdateSize(ReadOnlySpan<byte> item, bool add = true)
         }
 
         /// <inheritdoc />
-        public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0)
+        public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0, bool isNoValue = false)
         {
             cursor = start;
             items = new List<byte[]>();
diff --git a/libs/server/Objects/SortedSet/SortedSetObject.cs b/libs/server/Objects/SortedSet/SortedSetObject.cs
@@ -304,7 +304,7 @@ public override unsafe bool Operate(ref ObjectInput input, ref SpanByteAndMemory
                         break;
                     case SortedSetOperation.ZSCAN:
                         if (ObjectUtils.ReadScanInput(ref input, ref output, out var cursorInput, out var pattern,
-                                out var patternLength, out var limitCount, out var error))
+                                out var patternLength, out var limitCount, out var _, out var error))
                         {
                             Scan(cursorInput, out var items, out var cursorOutput, count: limitCount, pattern: pattern,
                                 patternLength: patternLength);
@@ -326,7 +326,7 @@ public override unsafe bool Operate(ref ObjectInput input, ref SpanByteAndMemory
         }
 
         /// <inheritdoc />
-        public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0)
+        public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0, bool isNoValue = false)
         {
             cursor = start;
             items = new List<byte[]>();
diff --git a/libs/server/Objects/Types/GarnetObjectBase.cs b/libs/server/Objects/Types/GarnetObjectBase.cs
@@ -146,6 +146,6 @@ private bool MakeTransition(SerializationPhase expectedPhase, SerializationPhase
         /// <param name="pattern">A patter used to match the members of the collection</param>
         /// <param name="patternLength">The number of characters in the pattern</param>
         /// <returns></returns>
-        public abstract unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0);
+        public abstract unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0, bool isNoValue = false);
     }
 }
diff --git a/libs/server/Objects/Types/IGarnetObject.cs b/libs/server/Objects/Types/IGarnetObject.cs
@@ -58,6 +58,6 @@ public interface IGarnetObject : IDisposable
         /// <param name="pattern">A patter used to match the members of the collection</param>
         /// <param name="patternLength">The number of characters in the pattern</param>
         /// <returns></returns>
-        unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0);
+        unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0, bool isNoValue = false);
     }
 }
diff --git a/libs/server/Resp/CmdStrings.cs b/libs/server/Resp/CmdStrings.cs
@@ -71,6 +71,8 @@ static partial class CmdStrings
         public static ReadOnlySpan<byte> match => "match"u8;
         public static ReadOnlySpan<byte> COUNT => "COUNT"u8;
         public static ReadOnlySpan<byte> count => "count"u8;
+        public static ReadOnlySpan<byte> NOVALUES => "NOVALUES"u8;
+        public static ReadOnlySpan<byte> novalues => "novalues"u8;
         public static ReadOnlySpan<byte> TYPE => "TYPE"u8;
         public static ReadOnlySpan<byte> type => "type"u8;
         public static ReadOnlySpan<byte> REGISTERCS => "REGISTERCS"u8;
diff --git a/main/GarnetServer/Extensions/MyDictObject.cs b/main/GarnetServer/Extensions/MyDictObject.cs
@@ -79,7 +79,7 @@ public override void Dispose() { }
         /// <param name="pattern"></param>
         /// <param name="patternLength"></param>
         /// <returns></returns>
-        public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = null, int patternLength = 0)
+        public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = null, int patternLength = 0, bool isNoValue = false)
         {
             cursor = start;
             items = new();
diff --git a/playground/GarnetJSON/JsonObject.cs b/playground/GarnetJSON/JsonObject.cs
@@ -216,6 +216,6 @@ public bool TryGet(string path, out string jsonString, ILogger? logger = null)
         }
 
         /// <inheritdoc/>
-        public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = null, int patternLength = 0) => throw new NotImplementedException();
+        public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = null, int patternLength = 0, bool isNoValue = false) => throw new NotImplementedException();
     }
 }
diff --git a/test/Garnet.test/RespHashTests.cs b/test/Garnet.test/RespHashTests.cs
@@ -413,6 +413,16 @@ public void CanDoHashScan()
 
             members = db.HashScan("user:user789", "*");
             ClassicAssert.IsTrue(members.Count() == 5, "HSCAN with MATCH failed.");
+
+            var fields = db.HashScanNoValues("user:user789", "*");
+            ClassicAssert.IsTrue(fields.Count() == 5, "HSCAN with MATCH failed.");
+            CollectionAssert.AreEquivalent(new[] { "email", "email1", "email2", "email3", "age" }, fields.Select(f => f.ToString()));
+
+            RedisResult result = db.Execute("HSCAN", "user:user789", "0", "MATCH", "*", "COUNT", "2", "NOVALUES");
+            ClassicAssert.IsTrue(result.Length == 2);
+            var fieldsStr = ((RedisResult[]?)result[1]).Select(x => (string)x).ToArray();
+            ClassicAssert.IsTrue(fieldsStr.Length == 2, "HSCAN with MATCH failed.");
+            CollectionAssert.AreEquivalent(new[] { "email", "email1" }, fieldsStr);
         }
 
 
diff --git a/website/docs/commands/api-compatibility.md b/website/docs/commands/api-compatibility.md
@@ -180,7 +180,7 @@ Note that this list is subject to change as we continue to expand our API comman
 |  | HPEXPIRETIME | ➖ |  |
 |  | HPTTL | ➖ |  |
 |  | [HRANDFIELD](data-structures.md#hrandfield) | ➕ |  |
-|  | [HSCAN](data-structures.md#hscan) | ➕ | `NOVALUES` flag not yet implemented |
+|  | [HSCAN](data-structures.md#hscan) | ➕ |  |
 |  | [HSET](data-structures.md#hset) | ➕ |  |
 |  | [HSETNX](data-structures.md#hsetnx) | ➕ |  |
 |  | [HSTRLEN](data-structures.md#hstrlen) | ➕ |  |
diff --git a/website/docs/commands/data-structures.md b/website/docs/commands/data-structures.md
@@ -159,13 +159,15 @@ The optional WITHVALUES modifier changes the reply so it includes the respective
 #### Syntax
 
 ```bash
-    HSCAN key cursor [MATCH pattern] [COUNT count]
+    HSCAN key cursor [MATCH pattern] [COUNT count] [NOVALUES]
 ```
 
 Iterates over the fields and values of a hash stored at a given **key**. Same as [SSCAN](#sscan) and [ZSCAN](#zscan) commands, **HSCAN** is used in order to incrementally iterate over the elements of the hash set*.
 
 The **match** parameter allows to apply a filter to elements after they have been retrieved from the collection. The **count** option sets a limit to the maximum number of items returned from the server to this command. This limit is also set in conjunction with the object-scan-count-limit of the global server settings.
 
+You can use the **NOVALUES** option to make Redis return only the keys in the hash table without their corresponding values
+
 ---
 
 ### HSET    

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ public sealed override unsafe bool Operate(ref ObjectInput input, ref SpanByteAn`
`78`	`78`	`// Scan Command`
`79`	`79`	`case RespCommand.COSCAN:`
`80`	`80`	`if (ObjectUtils.ReadScanInput(ref input, ref output, out var cursorInput, out var pattern,`
`81`		`- out var patternLength, out var limitCount, out var error))`
	`81`	`+ out var patternLength, out var limitCount, out bool _, out var error))`
`82`	`82`	`{`
`83`	`83`	`Scan(cursorInput, out var items, out var cursorOutput, count: limitCount, pattern: pattern,`
`84`	`84`	`patternLength: patternLength);`
Original file line number	Diff line number	Diff line change
`@@ -172,10 +172,10 @@ public override unsafe bool Operate(ref ObjectInput input, ref SpanByteAndMemory`
`172`	`172`	`break;`
`173`	`173`	`case HashOperation.HSCAN:`
`174`	`174`	`if (ObjectUtils.ReadScanInput(ref input, ref output, out var cursorInput, out var pattern,`
`175`		`- out var patternLength, out var limitCount, out var error))`
	`175`	`+ out var patternLength, out var limitCount, out bool isNoValue, out var error))`
`176`	`176`	`{`
`177`	`177`	`Scan(cursorInput, out var items, out var cursorOutput, count: limitCount, pattern: pattern,`
`178`		`- patternLength: patternLength);`
	`178`	`+ patternLength: patternLength, isNoValue);`
`179`	`179`	`ObjectUtils.WriteScanOutput(items, cursorOutput, ref output);`
`180`	`180`	`}`
`181`	`181`	`else`
`@@ -203,7 +203,7 @@ private void UpdateSize(ReadOnlySpan<byte> key, ReadOnlySpan<byte> value, bool a`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`/// <inheritdoc />`
`206`		`- public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0)`
	`206`	`+ public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0, bool isNoValue = false)`
`207`	`207`	`{`
`208`	`208`	`cursor = start;`
`209`	`209`	`items = new List<byte[]>();`
`@@ -215,7 +215,7 @@ public override unsafe void Scan(long start, out List<byte[]> items, out long cu`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`// Hashset has key and value, so count is multiplied by 2`
`218`		`- count *= 2;`
	`218`	`+ count = isNoValue ? count : count * 2;`
`219`	`219`	`int index = 0;`
`220`	`220`	`foreach (var item in hash)`
`221`	`221`	`{`
`@@ -228,7 +228,10 @@ public override unsafe void Scan(long start, out List<byte[]> items, out long cu`
`228`	`228`	`if (patternLength == 0)`
`229`	`229`	`{`
`230`	`230`	`items.Add(item.Key);`
`231`		`- items.Add(item.Value);`
	`231`	`+ if (!isNoValue)`
	`232`	`+ {`
	`233`	`+ items.Add(item.Value);`
	`234`	`+ }`
`232`	`235`	`}`
`233`	`236`	`else`
`234`	`237`	`{`
`@@ -237,7 +240,10 @@ public override unsafe void Scan(long start, out List<byte[]> items, out long cu`
`237`	`240`	`if (GlobUtils.Match(pattern, patternLength, keyPtr, item.Key.Length))`
`238`	`241`	`{`
`239`	`242`	`items.Add(item.Key);`
`240`		`- items.Add(item.Value);`
	`243`	`+ if (!isNoValue)`
	`244`	`+ {`
	`245`	`+ items.Add(item.Value);`
	`246`	`+ }`
`241`	`247`	`}`
`242`	`248`	`}`
`243`	`249`	`}`
Original file line number	Diff line number	Diff line change
`@@ -203,7 +203,7 @@ internal void UpdateSize(byte[] item, bool add = true)`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`/// <inheritdoc />`
`206`		`- public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0)`
	`206`	`+ public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0, bool isNoValue = false)`
`207`	`207`	`{`
`208`	`208`	`throw new NotImplementedException("For scan items in a list use LRANGE command");`
`209`	`209`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ public static unsafe void ReallocateOutput(ref SpanByteAndMemory output, ref boo`
`49`	`49`	`/// <param name="error"></param>`
`50`	`50`	`/// <returns></returns>`
`51`	`51`	`public static unsafe bool ReadScanInput(ref ObjectInput input, ref SpanByteAndMemory output,`
`52`		`- out int cursorInput, out byte* pattern, out int patternLength, out int countInInput, out ReadOnlySpan<byte> error)`
	`52`	`+ out int cursorInput, out byte* pattern, out int patternLength, out int countInInput, out bool isNoValue, out ReadOnlySpan<byte> error)`
`53`	`53`	`{`
`54`	`54`	`var currTokenIdx = input.parseStateStartIdx;`
`55`	`55`
`@@ -66,6 +66,7 @@ public static unsafe bool ReadScanInput(ref ObjectInput input, ref SpanByteAndMe`
`66`	`66`	`countInInput = 10;`
`67`	`67`
`68`	`68`	`error = default;`
	`69`	`+ isNoValue = false;`
`69`	`70`
`70`	`71`	`while (currTokenIdx < input.parseState.Count)`
`71`	`72`	`{`
`@@ -90,6 +91,10 @@ public static unsafe bool ReadScanInput(ref ObjectInput input, ref SpanByteAndMe`
`90`	`91`	`if (countInInput > limitCountInOutput)`
`91`	`92`	`countInInput = limitCountInOutput;`
`92`	`93`	`}`
	`94`	`+ else if (sbParam.SequenceEqual(CmdStrings.NOVALUES) \|\| sbParam.SequenceEqual(CmdStrings.novalues))`
	`95`	`+ {`
	`96`	`+ isNoValue = true;`
	`97`	`+ }`
`93`	`98`	`}`
`94`	`99`
`95`	`100`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ public override unsafe bool Operate(ref ObjectInput input, ref SpanByteAndMemory`
`143`	`143`	`break;`
`144`	`144`	`case SetOperation.SSCAN:`
`145`	`145`	`if (ObjectUtils.ReadScanInput(ref input, ref output, out var cursorInput, out var pattern,`
`146`		`- out var patternLength, out var limitCount, out var error))`
	`146`	`+ out var patternLength, out var limitCount, out bool _, out var error))`
`147`	`147`	`{`
`148`	`148`	`Scan(cursorInput, out var items, out var cursorOutput, count: limitCount, pattern: pattern,`
`149`	`149`	`patternLength: patternLength);`
`@@ -172,7 +172,7 @@ internal void UpdateSize(ReadOnlySpan<byte> item, bool add = true)`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`/// <inheritdoc />`
`175`		`- public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0)`
	`175`	`+ public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0, bool isNoValue = false)`
`176`	`176`	`{`
`177`	`177`	`cursor = start;`
`178`	`178`	`items = new List<byte[]>();`
Original file line number	Diff line number	Diff line change
`@@ -304,7 +304,7 @@ public override unsafe bool Operate(ref ObjectInput input, ref SpanByteAndMemory`
`304`	`304`	`break;`
`305`	`305`	`case SortedSetOperation.ZSCAN:`
`306`	`306`	`if (ObjectUtils.ReadScanInput(ref input, ref output, out var cursorInput, out var pattern,`
`307`		`- out var patternLength, out var limitCount, out var error))`
	`307`	`+ out var patternLength, out var limitCount, out var _, out var error))`
`308`	`308`	`{`
`309`	`309`	`Scan(cursorInput, out var items, out var cursorOutput, count: limitCount, pattern: pattern,`
`310`	`310`	`patternLength: patternLength);`
`@@ -326,7 +326,7 @@ public override unsafe bool Operate(ref ObjectInput input, ref SpanByteAndMemory`
`326`	`326`	`}`
`327`	`327`
`328`	`328`	`/// <inheritdoc />`
`329`		`- public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0)`
	`329`	`+ public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0, bool isNoValue = false)`
`330`	`330`	`{`
`331`	`331`	`cursor = start;`
`332`	`332`	`items = new List<byte[]>();`
Original file line number	Diff line number	Diff line change
`@@ -146,6 +146,6 @@ private bool MakeTransition(SerializationPhase expectedPhase, SerializationPhase`
`146`	`146`	`/// <param name="pattern">A patter used to match the members of the collection</param>`
`147`	`147`	`/// <param name="patternLength">The number of characters in the pattern</param>`
`148`	`148`	`/// <returns></returns>`
`149`		`- public abstract unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0);`
	`149`	`+ public abstract unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0, bool isNoValue = false);`
`150`	`150`	`}`
`151`	`151`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,6 @@ public interface IGarnetObject : IDisposable`
`58`	`58`	`/// <param name="pattern">A patter used to match the members of the collection</param>`
`59`	`59`	`/// <param name="patternLength">The number of characters in the pattern</param>`
`60`	`60`	`/// <returns></returns>`
`61`		`- unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0);`
	`61`	`+ unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = default, int patternLength = 0, bool isNoValue = false);`
`62`	`62`	`}`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ public override void Dispose() { }`
`79`	`79`	`/// <param name="pattern"></param>`
`80`	`80`	`/// <param name="patternLength"></param>`
`81`	`81`	`/// <returns></returns>`
`82`		`- public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = null, int patternLength = 0)`
	`82`	`+ public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = null, int patternLength = 0, bool isNoValue = false)`
`83`	`83`	`{`
`84`	`84`	`cursor = start;`
`85`	`85`	`items = new();`
Original file line number	Diff line number	Diff line change
`@@ -216,6 +216,6 @@ public bool TryGet(string path, out string jsonString, ILogger? logger = null)`
`216`	`216`	`}`
`217`	`217`
`218`	`218`	`/// <inheritdoc/>`
`219`		`- public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = null, int patternLength = 0) => throw new NotImplementedException();`
	`219`	`+ public override unsafe void Scan(long start, out List<byte[]> items, out long cursor, int count = 10, byte* pattern = null, int patternLength = 0, bool isNoValue = false) => throw new NotImplementedException();`
`220`	`220`	`}`
`221`	`221`	`}`