Native ETag Support

libs/common/RespReadUtils.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Buffers.Text;
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
@@ -458,6 +459,47 @@ public static bool TryRead64Int(out long number, ref byte* ptr, byte* end, out b
             return true;
         }
 
+        /// <summary>
+        /// Given a buffer check if the value is nil ($-1\r\n)
+        /// If the value is nil it advances the buffer forward
+        /// </summary>
+        /// <param name="ptr">The starting position in the RESP string. Will be advanced if parsing is successful.</param>
+        /// <param name="end">The current end of the RESP string.</param>
+        /// <param name="unexpectedToken"></param>
+        /// <returns>True if value is nil on the buffer, false if the value on buffer is not nil</returns>
+        public static bool ReadNil(ref byte* ptr, byte* end, out byte? unexpectedToken)
+        {
+            unexpectedToken = null;
+            if (end - ptr < 5)
+            {
+                return false;
+            }
+
+            ReadOnlySpan<byte> expectedNilRepr = "$-1\r\n"u8;
+
+            if (*(uint*)ptr != MemoryMarshal.Read<uint>(expectedNilRepr.Slice(0, 4)) || *(ptr + 4) != expectedNilRepr[4])
+            {
+                ReadOnlySpan<byte> ptrNext5Bytes = new ReadOnlySpan<byte>(ptr, 5);
+                for (int i = 0; i < 5; i++)
+                {
+                    // first place where the sequence differs we have found the unexpected token
+                    if (expectedNilRepr[i] != ptrNext5Bytes[i])
+                    {
+                        // move the pointer to the unexpected token
+                        ptr += i;
+                        unexpectedToken = ptrNext5Bytes[i];
+                        return false;
+                    }
+                }
+                // If the sequence is not equal we shouldn't even reach this because atleast one byte should have mismatched
+                Debug.Assert(false);
+                return false;
+            }
+
+            ptr += 5;
+            return true;
+        }
+
         /// <summary>
         /// Tries to read a RESP array length header from the given ASCII-encoded RESP string
         /// and, if successful, moves the given ptr to the end of the length header.

libs/resources/RespCommandsDocs.json

@@ -4443,6 +4443,45 @@
         "DisplayText": "newkey",
         "Type": "Key",
         "KeySpecIndex": 1
+      },
+      {
+        "TypeDiscriminator": "RespCommandBasicArgument",
+        "Name": "WITHETAG",
+        "DisplayText": "WITHETAG",
+        "Type": "PureToken",
+        "ArgumentFlags": "Optional",
+        "Token": "WITHETAG"
+      }
+    ]
+  },
+  {
+    "Command": "RENAMENX",
+    "Name": "RENAMENX",
+    "Summary": "Renames a key and overwrites the destination if the newkey does not exist.",
+    "Group": "Generic",
+    "Complexity": "O(1)",
+    "Arguments": [
+      {
+        "TypeDiscriminator": "RespCommandKeyArgument",
+        "Name": "KEY",
+        "DisplayText": "key",
+        "Type": "Key",
+        "KeySpecIndex": 0
+      },
+      {
+        "TypeDiscriminator": "RespCommandKeyArgument",
+        "Name": "NEWKEY",
+        "DisplayText": "newkey",
+        "Type": "Key",
+        "KeySpecIndex": 1
+      },
+      {
+        "TypeDiscriminator": "RespCommandBasicArgument",
+        "Name": "WITHETAG",
+        "DisplayText": "WITHETAG",
+        "Type": "PureToken",
+        "ArgumentFlags": "Optional",
+        "Token": "WITHETAG"
       }
     ]
   },
@@ -4873,6 +4912,14 @@
         "Token": "GET",
         "ArgumentFlags": "Optional"
       },
+      {
+        "TypeDiscriminator": "RespCommandBasicArgument",
+        "Name": "WITHETAG",
+        "DisplayText": "WITHETAG",
+        "Type": "PureToken",
+        "ArgumentFlags": "Optional",
+        "Token": "WITHETAG"
+      },
       {
         "TypeDiscriminator": "RespCommandContainerArgument",
         "Name": "EXPIRATION",
@@ -4918,6 +4965,94 @@
       }
     ]
   },
+  {
+    "Command": "GETIFNOTMATCH",
+    "Name": "GETIFNOTMATCH",
+    "Summary": "Gets the ETag and value if the key\u0027s current etag does not match the given etag.",
+    "Group": "String",
+    "Complexity": "O(1)",
+    "Arguments": [
+      {
+        "TypeDiscriminator": "RespCommandKeyArgument",
+        "Name": "KEY",
+        "DisplayText": "key",
+        "Type": "Key",
+        "KeySpecIndex": 0
+      },
+      {
+        "TypeDiscriminator": "RespCommandBasicArgument",
+        "Name": "ETAG",
+        "DisplayText": "etag",
+        "Type": "Integer"
+      }
+    ]
+  },
+  {
+    "Command": "GETWITHETAG",
+    "Name": "GETWITHETAG",
+    "Summary": "Gets the ETag and value for the key",
+    "Group": "String",
+    "Complexity": "O(1)",
+    "Arguments": [
+      {
+        "TypeDiscriminator": "RespCommandKeyArgument",
+        "Name": "KEY",
+        "DisplayText": "key",
+        "Type": "Key",
+        "KeySpecIndex": 0
+      }
+    ]
+  },
+  {
+    "Command": "SETIFMATCH",
+    "Name": "SETIFMATCH",
+    "Summary": "Sets the string value of a key, ignoring its type, if the key\u0027s current etag matches the given etag.",
+    "Group": "String",
+    "Complexity": "O(1)",
+    "Arguments": [
+      {
+        "TypeDiscriminator": "RespCommandKeyArgument",
+        "Name": "KEY",
+        "DisplayText": "key",
+        "Type": "Key",
+        "KeySpecIndex": 0
+      },
+      {
+        "TypeDiscriminator": "RespCommandBasicArgument",
+        "Name": "VALUE",
+        "DisplayText": "value",
+        "Type": "String"
+      },
+      {
+        "TypeDiscriminator": "RespCommandBasicArgument",
+        "Name": "ETAG",
+        "DisplayText": "etag",
+        "Type": "Integer"
+      },
+      {
+        "TypeDiscriminator": "RespCommandContainerArgument",
+        "Name": "EXPIRATION",
+        "Type": "OneOf",
+        "ArgumentFlags": "Optional",
+        "Arguments": [
+          {
+            "TypeDiscriminator": "RespCommandBasicArgument",
+            "Name": "SECONDS",
+            "DisplayText": "seconds",
+            "Type": "Integer",
+            "Token": "EX"
+          },
+          {
+            "TypeDiscriminator": "RespCommandBasicArgument",
+            "Name": "MILLISECONDS",
+            "DisplayText": "milliseconds",
+            "Type": "Integer",
+            "Token": "PX"
+          }
+        ]
+      }
+    ]
+  },
   {
     "Command": "SETBIT",
     "Name": "SETBIT",

libs/resources/RespCommandsInfo.json

@@ -1496,6 +1496,20 @@
       }
     ]
   },
+  {
+    "Command": "GETIFNOTMATCH",
+    "Name": "GETIFNOTMATCH",
+    "IsInternal": false,
+    "Arity": 3,
+    "Flags": "NONE",
+    "FirstKey": 1,
+    "LastKey": 1,
+    "Step": 1,
+    "AclCategories": "Fast, String, Read",
+    "Tips": null,
+    "KeySpecifications": null,
+    "SubCommands": null
+  },
   {
     "Command": "GETRANGE",
     "Name": "GETRANGE",
@@ -1546,6 +1560,20 @@
       }
     ]
   },
+  {
+    "Command": "GETWITHETAG",
+    "Name": "GETWITHETAG",
+    "IsInternal": false,
+    "Arity": 2,
+    "Flags": "NONE",
+    "FirstKey": 1,
+    "LastKey": 1,
+    "Step": 1,
+    "AclCategories": "Fast, String, Read",
+    "Tips": null,
+    "KeySpecifications": null,
+    "SubCommands": null
+  },
   {
     "Command": "HDEL",
     "Name": "HDEL",
@@ -2981,7 +3009,7 @@
   {
     "Command": "RENAME",
     "Name": "RENAME",
-    "Arity": 3,
+    "Arity": -3,
     "Flags": "Write",
     "FirstKey": 1,
     "LastKey": 2,
@@ -3019,7 +3047,7 @@
   {
     "Command": "RENAMENX",
     "Name": "RENAMENX",
-    "Arity": 3,
+    "Arity": -3,
     "Flags": "Fast, Write",
     "FirstKey": 1,
     "LastKey": 2,
@@ -3475,6 +3503,33 @@
       }
     ]
   },
+  {
+    "Command": "SETEXNX",
+    "Name": "SETEXNX",
+    "Arity": -3,
+    "Flags": "NONE",
+    "FirstKey": 1,
+    "LastKey": 1,
+    "Step": 1,
+    "AclCategories": "Fast, String, Write, Transaction",
+    "Tips": null,
+    "KeySpecifications": null,
+    "SubCommands": null
+  },
+  {
+    "Command": "SETIFMATCH",
+    "Name": "SETIFMATCH",
+    "IsInternal": false,
+    "Arity": -4,
+    "Flags": "NONE",
+    "FirstKey": 1,
+    "LastKey": 1,
+    "Step": 1,
+    "AclCategories": "Fast, String, Write",
+    "Tips": null,
+    "KeySpecifications": null,
+    "SubCommands": null
+  },
   {
     "Command": "SETRANGE",
     "Name": "SETRANGE",

libs/server/AOF/AofProcessor.cs

@@ -320,6 +320,9 @@ static unsafe void StoreRMW(BasicContext<SpanByte, SpanByte, RawStringInput, Spa
             // input
             storeInput.DeserializeFrom(curr);
 
+            if (storeInput.header.CheckWithEtagFlag())
+                EtagOffsetManagementContext.SetEtagOffsetBasedOnInputHeader(ref storeInput.etagOffsetManagementContext);
+
             var pbOutput = stackalloc byte[32];
             var output = new SpanByteAndMemory(pbOutput, 32);
 

libs/server/API/GarnetApi.cs

@@ -176,12 +176,12 @@ public GarnetStatus APPEND(ArgSlice key, ArgSlice value, ref ArgSlice output)
 
         #region RENAME
         /// <inheritdoc />
-        public GarnetStatus RENAME(ArgSlice oldKey, ArgSlice newKey, StoreType storeType = StoreType.All)
-            => storageSession.RENAME(oldKey, newKey, storeType);
+        public GarnetStatus RENAME(ArgSlice oldKey, ArgSlice newKey, bool withEtag, StoreType storeType = StoreType.All)
+            => storageSession.RENAME(oldKey, newKey, storeType, withEtag);
 
         /// <inheritdoc />
-        public GarnetStatus RENAMENX(ArgSlice oldKey, ArgSlice newKey, out int result, StoreType storeType = StoreType.All)
-            => storageSession.RENAMENX(oldKey, newKey, storeType, out result);
+        public GarnetStatus RENAMENX(ArgSlice oldKey, ArgSlice newKey, out int result, bool withEtag, StoreType storeType = StoreType.All)
+            => storageSession.RENAMENX(oldKey, newKey, storeType, out result, withEtag);
         #endregion
 
         #region EXISTS

libs/server/API/GarnetStatus.cs

@@ -23,6 +23,6 @@ public enum GarnetStatus : byte
         /// <summary>
         /// Wrong type
         /// </summary>
-        WRONGTYPE
+        WRONGTYPE,
     }
 }

libs/server/API/IGarnetApi.cs

@@ -131,7 +131,7 @@ public interface IGarnetApi : IGarnetReadApi, IGarnetAdvancedApi
         /// <param name="newKey"></param>
         /// <param name="storeType"></param>
         /// <returns></returns>
-        GarnetStatus RENAME(ArgSlice oldKey, ArgSlice newKey, StoreType storeType = StoreType.All);
+        GarnetStatus RENAME(ArgSlice oldKey, ArgSlice newKey, bool withEtag, StoreType storeType = StoreType.All);
 
         /// <summary>
         /// Renames key to newkey if newkey does not yet exist. It returns an error when key does not exist.
@@ -141,7 +141,7 @@ public interface IGarnetApi : IGarnetReadApi, IGarnetAdvancedApi
         /// <param name="result">The result of the operation.</param>
         /// <param name="storeType">The type of store to perform the operation on.</param>
         /// <returns></returns>
-        GarnetStatus RENAMENX(ArgSlice oldKey, ArgSlice newKey, out int result, StoreType storeType = StoreType.All);
+        GarnetStatus RENAMENX(ArgSlice oldKey, ArgSlice newKey, out int result, bool withEtag, StoreType storeType = StoreType.All);
         #endregion
 
         #region EXISTS

libs/server/Constants.cs

@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+
+namespace Garnet.server
+{
+    internal static class Constants
+    {
+        public const int EtagSize = sizeof(long);
+
+        public const int BaseEtag = 0;
+    }
+}

libs/server/Custom/CustomFunctions.cs

@@ -116,6 +116,17 @@ protected static unsafe void WriteBulkStringArray(ref MemoryResult<byte> output,
             }
         }
 
+        /// <summary>
+        /// Create output as bulk string, from given Span
+        /// </summary>
+        protected static unsafe void WriteBulkString(ref MemoryResult<byte> output, Span<byte> simpleString)
+        {
+            var _output = (output.MemoryOwner, output.Length);
+            WriteBulkString(ref _output, simpleString);
+            output.MemoryOwner = _output.MemoryOwner;
+            output.Length = _output.Length;
+        }
+
         /// <summary>
         /// Create output as bulk string, from given Span
         /// </summary>