clean up and optimize

Author: mgravell

src/StackExchange.Redis/Condition.cs

@@ -285,18 +285,18 @@ public static Condition StringNotEqual(RedisKey key, RedisValue value)
         public static Condition SortedSetNotContains(RedisKey key, RedisValue member) => new ExistsCondition(key, RedisType.SortedSet, member, false);
 
         /// <summary>
-        /// Enforces that the given sorted set contains a member that ist starting with the start-sequence.
+        /// Enforces that the given sorted set contains a member that starts with the specified prefix.
         /// </summary>
         /// <param name="key">The key of the sorted set to check.</param>
-        /// <param name="memberStartSequence">a byte array: the set must contain at least one member, that starts with the byte-sequence.</param>
-        public static Condition SortedSetStartsWith(RedisKey key, byte[] memberStartSequence) => new StartsWithCondition(key, memberStartSequence, true);
+        /// <param name="prefix">The sorted set must contain at least one member that starts with the specified prefix.</param>
+        public static Condition SortedSetContainsStarting(RedisKey key, RedisValue prefix) => new StartsWithCondition(key, prefix, true);
 
         /// <summary>
-        /// Enforces that the given sorted set does not contain a member that ist starting with the start-sequence.
+        /// Enforces that the given sorted set does not contain a member that starts with the specified prefix.
         /// </summary>
         /// <param name="key">The key of the sorted set to check.</param>
-        /// <param name="memberStartSequence">a byte array: the set must not contain any members, that start with the byte-sequence.</param>
-        public static Condition SortedSetNotStartsWith(RedisKey key, byte[] memberStartSequence) => new StartsWithCondition(key, memberStartSequence, false);
+        /// <param name="prefix">The sorted set must not contain at a member that starts with the specified prefix.</param>
+        public static Condition SortedSetNotContainsStarting(RedisKey key, RedisValue prefix) => new StartsWithCondition(key, prefix, false);
 
         /// <summary>
         /// Enforces that the given sorted set member must have the specified score.
@@ -541,35 +541,45 @@ internal sealed class StartsWithCondition : Condition
                working with byte arrays should prevent any encoding within this class, that could distort the comparison */
 
             private readonly bool expectedResult;
-            private readonly RedisValue expectedStartValue;
+            private readonly RedisValue prefix;
             private readonly RedisKey key;
 
             internal override Condition MapKeys(Func<RedisKey, RedisKey> map) =>
-                new StartsWithCondition(map(key), expectedStartValue, expectedResult);
+                new StartsWithCondition(map(key), prefix, expectedResult);
 
-            public StartsWithCondition(in RedisKey key, in RedisValue expectedStartValue, bool expectedResult)
+            public StartsWithCondition(in RedisKey key, in RedisValue prefix, bool expectedResult)
             {
                 if (key.IsNull) throw new ArgumentNullException(nameof(key));
-                if (expectedStartValue.IsNull) throw new ArgumentNullException(nameof(expectedStartValue));
+                if (prefix.IsNull) throw new ArgumentNullException(nameof(prefix));
                 this.key = key;
-                this.expectedStartValue = expectedStartValue;   // array with length 0 returns true condition
+                this.prefix = prefix;
                 this.expectedResult = expectedResult;
             }
 
             public override string ToString() =>
-                (expectedStartValue.IsNull ? key.ToString() : ((string?)key) + " " + RedisType.SortedSet + " > " + expectedStartValue)
-                    + (expectedResult ? " starts with" : " does not start with");
+                $"{key} {nameof(RedisType.SortedSet)} > {(expectedResult ? " member starting " : " no member starting ")} {prefix} + prefix";
 
             internal override void CheckCommands(CommandMap commandMap) => commandMap.AssertAvailable(RedisCommand.ZRANGEBYLEX);
 
             internal override IEnumerable<Message> CreateMessages(int db, IResultBox? resultBox)
             {
                 yield return Message.Create(db, CommandFlags.None, RedisCommand.WATCH, key);
 
-#pragma warning disable CS8600, CS8604, SA1117  // expectedStartValue is checked to be not null in Constructor and must be a byte[] because of API-parameters
-                var message = ConditionProcessor.CreateMessage(this, db, CommandFlags.None, RedisCommand.ZRANGEBYLEX, key,
-                        CombineBytes(91, (byte[])expectedStartValue.Box()), "+", "LIMIT", "0", "1"); // prepends '[' to startValue for inclusive search in CombineBytes
-#pragma warning disable CS8600, CS8604, SA1117
+                // prepend '[' to prefix for inclusive search
+                var startValueWithToken = RedisDatabase.GetLexRange(prefix, Exclude.None, isStart: true, Order.Ascending);
+
+                var message = ConditionProcessor.CreateMessage(
+                    this,
+                    db,
+                    CommandFlags.None,
+                    RedisCommand.ZRANGEBYLEX,
+                    key,
+                    startValueWithToken,
+                    RedisLiterals.PlusSymbol,
+                    RedisLiterals.LIMIT,
+                    0,
+                    1);
+
                 message.SetSource(ConditionProcessor.Default, resultBox);
                 yield return message;
             }
@@ -578,39 +588,9 @@ internal override IEnumerable<Message> CreateMessages(int db, IResultBox? result
 
             internal override bool TryValidate(in RawResult result, out bool value)
             {
-                RedisValue[]? r = result.GetItemsAsValues();
-                if (result.ItemsCount == 0) value = false; // false, if empty list -> read after end of memberlist / itemsCout > 1 is impossible due to 'LIMIT 0 1'
-#pragma warning disable CS8600, CS8604  // warnings on StartsWith can be ignored because of ItemsCount-check in then preceding command!!
-                else value = r != null && r.Length > 0 && StartsWith((byte[])r[0].Box(), expectedStartValue);
-#pragma warning disable CS8600, CS8604
+                value = result.ItemsCount == 1 && result[0].AsRedisValue().StartsWith(prefix);
 
-#pragma warning disable CS8602  // warning for r[0] can be ignored because of null-check in then same command-line !!
                 if (!expectedResult) value = !value;
-                ConnectionMultiplexer.TraceWithoutContext("actual: " + r == null ? "null" : r.Length == 0 ? "empty" : r[0].ToString()
-                                                        + "; expected: " + expectedStartValue.ToString()
-                                                        + "; wanted: " + (expectedResult ? "StartsWith" : "NotStartWith")
-                                                        + "; voting: " + value);
-#pragma warning restore CS8602
-                return true;
-            }
-
-            private static byte[] CombineBytes(byte b1, byte[] a1) // combines b1 and a1 to new array
-            {
-                byte[] newArray = new byte[a1.Length + 1];
-                newArray[0] = b1;
-                System.Buffer.BlockCopy(a1, 0, newArray, 1, a1.Length);
-                return newArray;
-            }
-
-            internal bool StartsWith(byte[] result, byte[] searchfor)
-            {
-                if (searchfor.Length > result.Length) return false;
-
-                for (int i = 0; i < searchfor.Length; i++)
-                {
-                    if (result[i] != searchfor[i]) return false;
-                }
-
                 return true;
             }
         }

src/StackExchange.Redis/FrameworkShims.cs

@@ -0,0 +1,39 @@
+#pragma warning disable SA1403 // single namespace
+
+#if NET5_0_OR_GREATER
+// context: https://github.com/StackExchange/StackExchange.Redis/issues/2619
+[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.CompilerServices.IsExternalInit))]
+#else
+// To support { get; init; } properties
+using System.ComponentModel;
+using System.Text;
+
+namespace System.Runtime.CompilerServices
+{
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    internal static class IsExternalInit { }
+}
+#endif
+
+#if !(NETCOREAPP || NETSTANDARD2_1_OR_GREATER)
+
+namespace System.Text
+{
+    internal static class EncodingExtensions
+    {
+        public static unsafe int GetBytes(this Encoding encoding, ReadOnlySpan<char> source, Span<byte> destination)
+        {
+            fixed (byte* bPtr = destination)
+            {
+                fixed (char* cPtr = source)
+                {
+                    return encoding.GetBytes(cPtr, source.Length, bPtr, destination.Length);
+                }
+            }
+        }
+    }
+}
+#endif
+
+
+#pragma warning restore SA1403

src/StackExchange.Redis/Hacks.cs

@@ -1951,5 +1951,3 @@ StackExchange.Redis.IDatabaseAsync.HashFieldSetAndSetExpiryAsync(StackExchange.R
 StackExchange.Redis.IDatabaseAsync.HashFieldSetAndSetExpiryAsync(StackExchange.Redis.RedisKey key, StackExchange.Redis.RedisValue field, StackExchange.Redis.RedisValue value, System.TimeSpan? expiry = null, bool keepTtl = false, StackExchange.Redis.When when = StackExchange.Redis.When.Always, StackExchange.Redis.CommandFlags flags = StackExchange.Redis.CommandFlags.None) -> System.Threading.Tasks.Task<StackExchange.Redis.RedisValue>!
 StackExchange.Redis.IDatabaseAsync.HashFieldSetAndSetExpiryAsync(StackExchange.Redis.RedisKey key, StackExchange.Redis.HashEntry[]! hashFields, System.DateTime expiry, StackExchange.Redis.When when = StackExchange.Redis.When.Always, StackExchange.Redis.CommandFlags flags = StackExchange.Redis.CommandFlags.None) -> System.Threading.Tasks.Task<StackExchange.Redis.RedisValue>!
 StackExchange.Redis.IDatabaseAsync.HashFieldSetAndSetExpiryAsync(StackExchange.Redis.RedisKey key, StackExchange.Redis.HashEntry[]! hashFields, System.TimeSpan? expiry = null, bool keepTtl = false, StackExchange.Redis.When when = StackExchange.Redis.When.Always, StackExchange.Redis.CommandFlags flags = StackExchange.Redis.CommandFlags.None) -> System.Threading.Tasks.Task<StackExchange.Redis.RedisValue>!
-static StackExchange.Redis.Condition.SortedSetStartsWith(StackExchange.Redis.RedisKey key, byte[]! memberStartSequence) -> StackExchange.Redis.Condition!
-static StackExchange.Redis.Condition.SortedSetNotStartsWith(StackExchange.Redis.RedisKey key, byte[]! memberStartSequence) -> StackExchange.Redis.Condition!

src/StackExchange.Redis/PublicAPI/PublicAPI.Shipped.txt

@@ -1 +1,6 @@
-#nullable enable
+#nullable enable
+StackExchange.Redis.RedisValue.CopyTo(System.Span<byte> destination) -> int
+StackExchange.Redis.RedisValue.GetByteCount() -> int
+StackExchange.Redis.RedisValue.GetLongByteCount() -> long
+static StackExchange.Redis.Condition.SortedSetContainsStarting(StackExchange.Redis.RedisKey key, StackExchange.Redis.RedisValue prefix) -> StackExchange.Redis.Condition!
+static StackExchange.Redis.Condition.SortedSetNotContainsStarting(StackExchange.Redis.RedisKey key, StackExchange.Redis.RedisValue prefix) -> StackExchange.Redis.Condition!

src/StackExchange.Redis/PublicAPI/PublicAPI.Unshipped.txt

@@ -3962,21 +3962,23 @@ private Message GetSortedSetMultiPopMessage(RedisKey[] keys, Order order, long c
             return tran;
         }
 
-        private static RedisValue GetLexRange(RedisValue value, Exclude exclude, bool isStart, Order order)
+        internal static RedisValue GetLexRange(RedisValue value, Exclude exclude, bool isStart, Order order)
         {
-            if (value.IsNull)
+            if (value.IsNull) // open search
             {
                 if (order == Order.Ascending) return isStart ? RedisLiterals.MinusSymbol : RedisLiterals.PlusSymbol;
 
-                return isStart ? RedisLiterals.PlusSymbol : RedisLiterals.MinusSymbol; // 24.01.2024: when descending order: Plus and Minus have to be reversed
+                return isStart ? RedisLiterals.PlusSymbol : RedisLiterals.MinusSymbol; // when descending order: Plus and Minus have to be reversed
             }
 
-            byte[] orig = value!;
+            var srcLength = value.GetByteCount();
+            Debug.Assert(srcLength >= 0);
 
-            byte[] result = new byte[orig.Length + 1];
+            byte[] result = new byte[srcLength + 1];
             // no defaults here; must always explicitly specify [ / (
             result[0] = (exclude & (isStart ? Exclude.Start : Exclude.Stop)) == 0 ? (byte)'[' : (byte)'(';
-            Buffer.BlockCopy(orig, 0, result, 1, orig.Length);
+            int written = value.CopyTo(result.AsSpan(1));
+            Debug.Assert(written == srcLength, "predicted/actual length mismatch");
             return result;
         }
 

src/StackExchange.Redis/RedisDatabase.cs

@@ -2,6 +2,7 @@
 using System.Buffers;
 using System.Buffers.Text;
 using System.ComponentModel;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -838,23 +839,78 @@ private static string ToHex(ReadOnlySpan<byte> src)
 
                     return value._memory.ToArray();
                 case StorageType.Int64:
-                    Span<byte> span = stackalloc byte[Format.MaxInt64TextLen + 2];
-                    int len = PhysicalConnection.WriteRaw(span, value.OverlappedValueInt64, false, 0);
-                    arr = new byte[len - 2]; // don't need the CRLF
-                    span.Slice(0, arr.Length).CopyTo(arr);
-                    return arr;
+                    Debug.Assert(Format.MaxInt64TextLen <= 24);
+                    Span<byte> span = stackalloc byte[24];
+                    int len = Format.FormatInt64(value.OverlappedValueInt64, span);
+                    return span.Slice(0, len).ToArray();
                 case StorageType.UInt64:
-                    // we know it is a huge value - just jump straight to Utf8Formatter
-                    span = stackalloc byte[Format.MaxInt64TextLen];
+                    Debug.Assert(Format.MaxInt64TextLen <= 24);
+                    span = stackalloc byte[24];
                     len = Format.FormatUInt64(value.OverlappedValueUInt64, span);
-                    arr = new byte[len];
-                    span.Slice(0, len).CopyTo(arr);
-                    return arr;
+                    return span.Slice(0, len).ToArray();
+                case StorageType.Double:
+                    span = stackalloc byte[128];
+                    len = Format.FormatDouble(value.OverlappedValueDouble, span);
+                    return span.Slice(0, len).ToArray();
+                case StorageType.String:
+                    return Encoding.UTF8.GetBytes((string)value._objectOrSentinel!);
             }
             // fallback: stringify and encode
             return Encoding.UTF8.GetBytes((string)value!);
         }
 
+        /// <summary>
+        /// Gets the length of the value in bytes.
+        /// </summary>
+        public int GetByteCount()
+        {
+            switch (Type)
+            {
+                case StorageType.Null: return 0;
+                case StorageType.Raw: return _memory.Length;
+                case StorageType.String: return Encoding.UTF8.GetByteCount((string)_objectOrSentinel!);
+                case StorageType.Int64: return Format.MeasureInt64(OverlappedValueInt64);
+                case StorageType.UInt64: return Format.MeasureUInt64(OverlappedValueUInt64);
+                case StorageType.Double: return Format.MeasureDouble(OverlappedValueDouble);
+                default: return ThrowUnableToMeasure();
+            }
+        }
+
+        private int ThrowUnableToMeasure() => throw new InvalidOperationException("Unable to compute length of type: " + Type);
+
+        /// <summary>
+        /// Gets the length of the value in bytes.
+        /// </summary>
+        /* right now, we only support int lengths, but adding this now so that
+         there are no surprises if/when we add support for discontiguous buffers */
+        public long GetLongByteCount() => GetByteCount();
+
+        /// <summary>
+        /// Copy the value as bytes to the provided <paramref name="destination"/>.
+        /// </summary>
+        public int CopyTo(Span<byte> destination)
+        {
+            switch (Type)
+            {
+                case StorageType.Null:
+                    return 0;
+                case StorageType.Raw:
+                    var srcBytes = _memory.Span;
+                    srcBytes.CopyTo(destination);
+                    return srcBytes.Length;
+                case StorageType.String:
+                    return Encoding.UTF8.GetBytes(((string)_objectOrSentinel!).AsSpan(), destination);
+                case StorageType.Int64:
+                    return Format.FormatInt64(OverlappedValueInt64, destination);
+                case StorageType.UInt64:
+                    return Format.FormatUInt64(OverlappedValueUInt64, destination);
+                case StorageType.Double:
+                    return Format.FormatDouble(OverlappedValueDouble, destination);
+                default:
+                    return ThrowUnableToMeasure();
+            }
+        }
+
         /// <summary>
         /// Converts a <see cref="RedisValue"/> to a <see cref="ReadOnlyMemory{T}"/>.
         /// </summary>

src/StackExchange.Redis/RedisValue.cs

@@ -832,7 +832,7 @@ public async Task BasicTranWithSortedSetStartsWithCondition(bool demandKeyExists
         Assert.Equal(keyExists, db.SortedSetScore(key2, member).HasValue);
 
         var tran = db.CreateTransaction();
-        var cond = tran.AddCondition(demandKeyExists ? Condition.SortedSetStartsWith(key2, startWith) : Condition.SortedSetNotStartsWith(key2, startWith));
+        var cond = tran.AddCondition(demandKeyExists ? Condition.SortedSetContainsStarting(key2, startWith) : Condition.SortedSetNotContainsStarting(key2, startWith));
         var incr = tran.StringIncrementAsync(key);
         var exec = tran.ExecuteAsync();
         var get = db.StringGet(key);