Don't ignore minimalPut parameter in ReadWriteCache

Author: bahusoid

src/NHibernate/Async/Cache/ReadWriteCache.cs

@@ -156,7 +156,7 @@ public async Task<bool[]> PutManyAsync(
 						var version = versions[i];
 						var lockable = (ILockable) lockables[i];
 						bool puttable = lockable == null ||
-						                lockable.IsPuttable(timestamp, version, versionComparers[i]);
+						                lockable.IsPuttable(timestamp, version, versionComparers[i], minimalPuts[i]);
 						if (puttable)
 						{
 							putBatch.Add(key, CachedItem.Create(values[i], Cache.NextTimestamp(), version));
@@ -222,7 +222,7 @@ public async Task<bool> PutAsync(CacheKey key, object value, long txTimestamp, o
 					ILockable lockable = (ILockable) await (Cache.GetAsync(key, cancellationToken)).ConfigureAwait(false);
 
 					bool puttable = lockable == null ||
-					                lockable.IsPuttable(txTimestamp, version, versionComparator);
+					                lockable.IsPuttable(txTimestamp, version, versionComparator, minimalPut);
 
 					if (puttable)
 					{

src/NHibernate/Cache/CacheLock.cs

@@ -14,7 +14,7 @@ namespace NHibernate.Cache
 	/// </remarks>
 	[Serializable]
 	[DataContract]
-	public class CacheLock : ReadWriteCache.ILockable, ISoftLock
+	public class CacheLock : ReadWriteCache.ILockable, ISoftLock, ReadWriteCache.ILockableNextVer
 	{
 		private long unlockTimestamp = -1;
 		private int multiplicity = 1;
@@ -75,7 +75,7 @@ public void Unlock(long currentTimestamp)
 		/// Can the timestamped transaction re-cache this
 		/// locked item now?
 		/// </summary>
-		public bool IsPuttable(long txTimestamp, object newVersion, IComparer comparator)
+		public bool IsPuttable(long txTimestamp, object newVersion, IComparer comparator, bool minimalPut)
 		{
 			if (Timeout < txTimestamp)
 			{
@@ -85,10 +85,20 @@ public bool IsPuttable(long txTimestamp, object newVersion, IComparer comparator
 			{
 				return false;
 			}
-			return Version == null ?
-			       UnlockTimestamp < txTimestamp :
-			       comparator.Compare(Version, newVersion) < 0;
-				//by requiring <, we rely on lock timeout in the case of an unsuccessful update!
+
+			return Version == null 
+				? UnlockTimestamp < txTimestamp 
+				: comparator.Compare(Version, newVersion) < (minimalPut ? 0 : 1);
+			//by requiring <, we rely on lock timeout in the case of an unsuccessful update!
+		}
+
+		/// <summary>
+		/// Can the timestamped transaction re-cache this
+		/// locked item now?
+		/// </summary>
+		public bool IsPuttable(long txTimestamp, object newVersion, IComparer comparator)
+		{
+			return IsPuttable(txTimestamp, newVersion, comparator, true);
 		}
 
 		/// <summary>

src/NHibernate/Cache/CachedItem.cs

@@ -10,7 +10,7 @@ namespace NHibernate.Cache
 	/// </summary>
 	[Serializable]
 	[DataContract]
-	public class CachedItem : ReadWriteCache.ILockable
+	public class CachedItem : ReadWriteCache.ILockable, ReadWriteCache.ILockableNextVer
 	{
 		private long freshTimestamp;
 		private object value;
@@ -104,15 +104,21 @@ public bool IsGettable(long txTimestamp)
 		/// <param name="txTimestamp"></param>
 		/// <param name="newVersion"></param>
 		/// <param name="comparator"></param>
+		/// <param name="minimalPut"></param>
 		/// <returns></returns>
+		public bool IsPuttable(long txTimestamp, object newVersion, IComparer comparator, bool minimalPut)
+		{
+			if (Version == null)
+				return !minimalPut;
+
+			return comparator.Compare(Version, newVersion) < (minimalPut ? 0 : 1);
+		}
+		
 		public bool IsPuttable(long txTimestamp, object newVersion, IComparer comparator)
 		{
-			// we really could refresh the item if it  
-			// is not a lock, but it might be slower
-			//return freshTimestamp < txTimestamp
-			return Version != null && comparator.Compare(Version, newVersion) < 0;
+			return IsPuttable(txTimestamp, newVersion, comparator, true);
 		}
-
+		
 		public override string ToString()
 		{
 			return "Item{version=" + Version +

src/NHibernate/Cache/ReadWriteCache.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
@@ -6,6 +7,22 @@
 
 namespace NHibernate.Cache
 {
+	public static class LocableExtension
+	{
+		//TODO 6.0: Remove after ILockableNextVer merge
+		internal static bool IsPuttable(this ReadWriteCache.ILockable lockable, long txTimestamp, object newVersion, IComparer comparator, bool minimalPut)
+		{
+			if (lockable is ReadWriteCache.ILockableNextVer l)
+			{
+				return l.IsPuttable(txTimestamp, newVersion, comparator, minimalPut);
+			}
+
+#pragma warning disable CS0618
+			return lockable.IsPuttable(txTimestamp, newVersion, comparator);
+#pragma warning restore CS0618
+		}
+	}
+
 	/// <summary>
 	/// Caches data that is sometimes updated while maintaining the semantics of
 	/// "read committed" isolation level. If the database is set to "repeatable
@@ -24,11 +41,20 @@ namespace NHibernate.Cache
 	/// </remarks>
 	public partial class ReadWriteCache : IBatchableCacheConcurrencyStrategy
 	{
+		//TODO 6.0: Merge with ILockable
+		internal interface ILockableNextVer
+		{
+			bool IsPuttable(long txTimestamp, object newVersion, IComparer comparator, bool minimalPut);
+		}
+
 		public interface ILockable
 		{
 			CacheLock Lock(long timeout, int id);
 			bool IsLock { get; }
 			bool IsGettable(long txTimestamp);
+
+			// Since 5.4
+			[Obsolete("Use overload with minimalPuts parameter")]
 			bool IsPuttable(long txTimestamp, object newVersion, IComparer comparator);
 		}
 
@@ -237,7 +263,7 @@ public bool[] PutMany(
 						var version = versions[i];
 						var lockable = (ILockable) lockables[i];
 						bool puttable = lockable == null ||
-						                lockable.IsPuttable(timestamp, version, versionComparers[i]);
+						                lockable.IsPuttable(timestamp, version, versionComparers[i], minimalPuts[i]);
 						if (puttable)
 						{
 							putBatch.Add(key, CachedItem.Create(values[i], Cache.NextTimestamp(), version));
@@ -301,7 +327,7 @@ public bool Put(CacheKey key, object value, long txTimestamp, object version, IC
 					ILockable lockable = (ILockable) Cache.Get(key);
 
 					bool puttable = lockable == null ||
-					                lockable.IsPuttable(txTimestamp, version, versionComparator);
+					                lockable.IsPuttable(txTimestamp, version, versionComparator, minimalPut);
 
 					if (puttable)
 					{