Single record updates / deletes (#73)

* single record updates

* single record deletion.

* fixing new-line incongruity.

* removing erroneous console writeline

Author: slorello89

src/Redis.OM/Modeling/RedisCollectionStateManager.cs

@@ -20,8 +20,6 @@ public class RedisCollectionStateManager
             DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
         };
 
-        private readonly DocumentAttribute _documentAttribute;
-
         static RedisCollectionStateManager()
         {
             JsonSerializerOptions.Converters.Add(new GeoLocJsonConverter());
@@ -34,9 +32,14 @@ static RedisCollectionStateManager()
         /// <param name="attr">The document attribute for the type.</param>
         public RedisCollectionStateManager(DocumentAttribute attr)
         {
-            _documentAttribute = attr;
+            DocumentAttribute = attr;
         }
 
+        /// <summary>
+        /// Gets the DocumentAttribute for the underlying type.
+        /// </summary>
+        public DocumentAttribute DocumentAttribute { get; }
+
         /// <summary>
         /// Gets a snapshot from when the collection enumerated.
         /// </summary>
@@ -47,19 +50,37 @@ public RedisCollectionStateManager(DocumentAttribute attr)
         /// </summary>
         internal IDictionary<string, object?> Data { get; set; } = new Dictionary<string, object?>();
 
+        /// <summary>
+        /// Removes the key from the data and snapshot.
+        /// </summary>
+        /// <param name="key">The key to remove.</param>
+        internal void Remove(string key)
+        {
+            Snapshot.Remove(key);
+            Data.Remove(key);
+        }
+
+        /// <summary>
+        /// Add item to data.
+        /// </summary>
+        /// <param name="key">the item's key.</param>
+        /// <param name="value">the item's value.</param>
+        internal void InsertIntoData(string key, object value)
+        {
+            Data.Remove(key);
+            Data.Add(key, value);
+        }
+
         /// <summary>
         /// Add item to snapshot.
         /// </summary>
         /// <param name="key">the item's key.</param>
         /// <param name="value">the current value of the item.</param>
         internal void InsertIntoSnapshot(string key, object value)
         {
-            if (Snapshot.ContainsKey(key))
-            {
-                return;
-            }
+            Snapshot.Remove(key);
 
-            if (_documentAttribute.StorageType == StorageType.Json)
+            if (DocumentAttribute.StorageType == StorageType.Json)
             {
                 var json = JToken.FromObject(value, Newtonsoft.Json.JsonSerializer.Create(new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }));
                 Snapshot.Add(key, json);
@@ -71,14 +92,53 @@ internal void InsertIntoSnapshot(string key, object value)
             }
         }
 
+        /// <summary>
+        /// Builds a diff for a single object from what's currently in the snapshot.
+        /// </summary>
+        /// <param name="key">the key of the object in redis.</param>
+        /// <param name="value">The current value.</param>
+        /// <param name="differences">The detected differences.</param>
+        /// <returns>Whether a diff could be constructed.</returns>
+        internal bool TryDetectDifferencesSingle(string key, object value, out IList<IObjectDiff>? differences)
+        {
+            if (!Snapshot.ContainsKey(key))
+            {
+                differences = null;
+                return false;
+            }
+
+            if (DocumentAttribute.StorageType == StorageType.Json)
+            {
+                var dataJson = JsonSerializer.Serialize(value, JsonSerializerOptions);
+                var current = JsonConvert.DeserializeObject<JObject>(dataJson, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
+                var snapshot = (JToken)Snapshot[key];
+                var diff = FindDiff(current!, snapshot);
+                differences = BuildJsonDifference(diff, "$");
+            }
+            else
+            {
+                var dataHash = value.BuildHashSet();
+                var snapshotHash = (IDictionary<string, string>)Snapshot[key];
+                var deletedKeys = snapshotHash.Keys.Except(dataHash.Keys).Select(x => new KeyValuePair<string, string>(x, string.Empty));
+                var modifiedKeys = dataHash.Where(x =>
+                    !snapshotHash.Keys.Contains(x.Key) || snapshotHash[x.Key] != x.Value);
+                differences = new List<IObjectDiff>
+                {
+                    new HashDiff(modifiedKeys, deletedKeys.Select(x => x.Key)),
+                };
+            }
+
+            return true;
+        }
+
         /// <summary>
         /// Detects the differences.
         /// </summary>
         /// <returns>a difference dictionary.</returns>
         internal IDictionary<string, IList<IObjectDiff>> DetectDifferences()
         {
             var res = new Dictionary<string, IList<IObjectDiff>>();
-            if (_documentAttribute.StorageType == StorageType.Json)
+            if (DocumentAttribute.StorageType == StorageType.Json)
             {
                 foreach (var key in Snapshot.Keys)
                 {
@@ -267,8 +327,12 @@ private static JObject FindDiff(JToken currentObject, JToken snapshotObject)
 
                     break;
                 default:
-                    diff["+"] = currentObject;
-                    diff["-"] = snapshotObject;
+                    if (currentObject.ToString() != snapshotObject.ToString())
+                    {
+                        diff["+"] = currentObject;
+                        diff["-"] = snapshotObject;
+                    }
+
                     break;
             }
 

src/Redis.OM/RedisCommands.cs

@@ -363,5 +363,44 @@ public static async Task<IDictionary<string, string>> HGetAllAsync(this IRedisCo
         /// <param name="key">the key to unlink.</param>
         /// <returns>the status.</returns>
         public static string Unlink(this IRedisConnection connection, string key) => connection.Execute("UNLINK", key);
+
+        /// <summary>
+        /// Unlinks a key.
+        /// </summary>
+        /// <param name="connection">the connection.</param>
+        /// <param name="key">the key to unlink.</param>
+        /// <returns>the status.</returns>
+        public static async Task<string> UnlinkAsync(this IRedisConnection connection, string key) => await connection.ExecuteAsync("UNLINK", key);
+
+        /// <summary>
+        /// Unlinks the key and then adds an updated value of it.
+        /// </summary>
+        /// <param name="connection">The connection to redis.</param>
+        /// <param name="key">The key.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="storageType">The storage type of the value.</param>
+        /// <typeparam name="T">The type of the value.</typeparam>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        internal static async Task UnlinkAndSet<T>(this IRedisConnection connection, string key, T value, StorageType storageType)
+        {
+            _ = value ?? throw new ArgumentNullException(nameof(value));
+            if (storageType == StorageType.Json)
+            {
+                await connection.CreateAndEvalAsync(nameof(Scripts.UnlinkAndSendJson), new[] { key }, new[] { JsonSerializer.Serialize(value, Options) });
+            }
+            else
+            {
+                var hash = value.BuildHashSet();
+                var args = new List<string>((hash.Keys.Count * 2) + 1);
+                args.Add(hash.Keys.Count.ToString());
+                foreach (var pair in hash)
+                {
+                    args.Add(pair.Key);
+                    args.Add(pair.Value);
+                }
+
+                await connection.CreateAndEvalAsync(nameof(Scripts.UnlinkAndSetHash), new[] { key }, args.ToArray());
+            }
+        }
     }
 }

src/Redis.OM/RedisObjectHandler.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
+using System.Text;
 using System.Text.Json;
 using Redis.OM.Contracts;
 using Redis.OM.Modeling;
@@ -95,6 +96,43 @@ internal static string GetId(this object obj)
             return string.Empty;
         }
 
+        /// <summary>
+        /// Gets the fully formed key name for the given object.
+        /// </summary>
+        /// <param name="obj">the object to pull the key from.</param>
+        /// <returns>The key.</returns>
+        /// <exception cref="ArgumentException">Thrown if type is invalid or there's no id present on the key.</exception>
+        internal static string GetKey(this object obj)
+        {
+            var type = obj.GetType();
+            var documentAttribute = (DocumentAttribute)type.GetCustomAttribute(typeof(DocumentAttribute));
+            if (documentAttribute == null)
+            {
+                throw new ArgumentException("Missing Document Attribute on Declaring class");
+            }
+
+            var id = obj.GetId();
+            if (string.IsNullOrEmpty(id))
+            {
+                throw new ArgumentException("Id field is not correctly populated");
+            }
+
+            var sb = new StringBuilder();
+            if (documentAttribute.Prefixes.Any())
+            {
+                sb.Append(documentAttribute.Prefixes.First());
+                sb.Append(":");
+            }
+            else
+            {
+                sb.Append(type.FullName);
+                sb.Append(":");
+            }
+
+            sb.Append(id);
+            return sb.ToString();
+        }
+
         /// <summary>
         /// Set's the id of the given field based off the objects id strategy.
         /// </summary>
@@ -214,7 +252,8 @@ internal static IDictionary<string, string> BuildHashSet(this object obj)
             var hash = new Dictionary<string, string>();
             foreach (var property in properties)
             {
-                var type = property.PropertyType;
+                var type = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType;
+
                 var propertyName = property.Name;
                 ExtractPropertyName(property, ref propertyName);
                 if (type.IsPrimitive || type == typeof(decimal) || type == typeof(string) || type == typeof(GeoLoc) || type == typeof(Ulid) || type == typeof(Guid))
@@ -286,7 +325,7 @@ private static string SendToJson(IDictionary<string, string> hash, Type t)
             var ret = "{";
             foreach (var property in properties)
             {
-                var type = property.PropertyType;
+                var type = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType;
                 var propertyName = property.Name;
                 ExtractPropertyName(property, ref propertyName);
                 if (!hash.Any(x => x.Key.StartsWith(propertyName)))

src/Redis.OM/Scripts.cs

@@ -60,6 +60,31 @@ local second_op
         internal const string Unlink = @"
 return redis.call('UNLINK',KEYS[1])";
 
+        /// <summary>
+        /// Unlinks and sets a key for a Hash model.
+        /// </summary>
+        internal const string UnlinkAndSetHash = @"
+redis.call('UNLINK',KEYS[1])
+local num_fields = ARGV[1]
+local end_index = num_fields * 2 + 1
+local args = {}
+for i = 2, end_index, 2 do
+    args[i-1] = ARGV[i]
+    args[i] = ARGV[i+1]
+end
+redis.call('HSET',KEYS[1],unpack(args))
+return 0
+";
+
+        /// <summary>
+        /// Unlinks a JSON object and sets the key again with a fresh new JSON object.
+        /// </summary>
+        internal const string UnlinkAndSendJson = @"
+redis.call('UNLINK', KEYS[1])
+redis.call('JSON.SET', KEYS[1], '.', ARGV[1])
+return 0
+";
+
         /// <summary>
         /// The scripts.
         /// </summary>
@@ -68,6 +93,8 @@ local second_op
             { nameof(JsonDiffResolution), JsonDiffResolution },
             { nameof(HashDiffResolution), HashDiffResolution },
             { nameof(Unlink), Unlink },
+            { nameof(UnlinkAndSetHash), UnlinkAndSetHash },
+            { nameof(UnlinkAndSendJson), UnlinkAndSendJson },
         };
 
         /// <summary>

src/Redis.OM/Searching/IRedisCollection.cs

@@ -68,5 +68,19 @@ public interface IRedisCollection<T> : IOrderedQueryable<T>, IAsyncEnumerable<T>
         /// <param name="expression">the expression to be matched.</param>
         /// <returns>Whether anything matching the expression was found.</returns>
         bool Any(Expression<Func<T, bool>> expression);
+
+        /// <summary>
+        /// Updates the provided item in Redis. Document must have a property marked with the <see cref="RedisIdFieldAttribute"/>.
+        /// </summary>
+        /// <param name="item">The item to update.</param>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        Task Update(T item);
+
+        /// <summary>
+        /// Deletes the item from Redis.
+        /// </summary>
+        /// <param name="item">The item to be deleted.</param>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        Task Delete(T item);
     }
 }

src/Redis.OM/Searching/RedisCollection.cs

@@ -84,6 +84,43 @@ public bool Any(Expression<Func<T, bool>> expression)
             return res.Documents.Values.Any();
         }
 
+        /// <inheritdoc />
+        public async Task Update(T item)
+        {
+            var key = item.GetKey();
+            IList<IObjectDiff>? diff;
+            var diffConstructed = StateManager.TryDetectDifferencesSingle(key, item, out diff);
+            if (diffConstructed)
+            {
+                if (diff!.Any())
+                {
+                    var args = new List<string>();
+                    var scriptName = diff!.First().Script;
+                    foreach (var update in diff!)
+                    {
+                        args.AddRange(update.SerializeScriptArgs());
+                    }
+
+                    await _connection.CreateAndEvalAsync(scriptName, new[] { key }, args.ToArray());
+                }
+            }
+            else
+            {
+                await _connection.UnlinkAndSet(key, item, StateManager.DocumentAttribute.StorageType);
+            }
+
+            StateManager.InsertIntoSnapshot(key, item);
+            StateManager.InsertIntoData(key, item);
+        }
+
+        /// <inheritdoc />
+        public async Task Delete(T item)
+        {
+            var key = item.GetKey();
+            await _connection.UnlinkAsync(key);
+            StateManager.Remove(key);
+        }
+
         /// <inheritdoc/>
         public IEnumerator<T> GetEnumerator()
         {
@@ -120,7 +157,6 @@ public void Save()
         public async ValueTask SaveAsync()
         {
             var diff = StateManager.DetectDifferences();
-            Console.WriteLine(diff);
             var tasks = new List<Task<int?>>();
             foreach (var item in diff)
             {

src/Redis.OM/Searching/RedisCollectionEnumerator.cs

@@ -182,7 +182,7 @@ private void ConcatenateRecords()
                     continue;
                 }
 
-                _stateManager.Data.Add(record.Key, record.Value);
+                _stateManager.InsertIntoData(record.Key, record.Value);
                 _stateManager.InsertIntoSnapshot(record.Key, record.Value);
             }
         }