Reduce the number of calls to UpdateTimestampsCache

src/AsyncGenerator.yml

@@ -4,8 +4,6 @@
   applyChanges: true
   analyzation:
     methodConversion:
-    - conversion: Ignore
-      hasAttributeName: ObsoleteAttribute
     - conversion: Ignore
       name: PostProcessInsert
       containingTypeName: HqlSqlWalker
@@ -96,6 +94,9 @@
     - conversion: Ignore
       name: Exists
       containingTypeName: AbstractCollectionPersister
+    - conversion: Ignore
+      name: QuoteTableAndColumns
+      containingTypeName: SchemaMetadataUpdater
     - conversion: ToAsync
       name: ExecuteReader
       containingTypeName: IBatcher
@@ -119,6 +120,8 @@
     - name: GetFieldValue
     - name: IsDBNull
     - name: WriteLine
+    ignoreAsyncCounterparts:
+    - rule: Obsolete
     callForwarding: true
     cancellationTokens:
       guards: true
@@ -259,6 +262,9 @@ methodRules:
   - containingType: NHibernate.Tool.hbm2ddl.SchemaValidator
   - containingType: NHibernate.Tool.hbm2ddl.SchemaExport
   name: PubliclyExposedType
+- filters:
+  - hasAttributeName: ObsoleteAttribute
+  name: Obsolete
 typeRules:
 - filters:
   - containingAssemblyName: NHibernate

src/NHibernate.Test/Async/SecondLevelCacheTest/InvalidationTests.cs

@@ -0,0 +1,115 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by AsyncGenerator.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using NHibernate.Cache;
+using NHibernate.Cfg;
+using NHibernate.Engine;
+using NHibernate.Impl;
+using NHibernate.Test.SecondLevelCacheTests;
+using NSubstitute;
+using NUnit.Framework;
+
+namespace NHibernate.Test.SecondLevelCacheTest
+{
+	using System.Threading.Tasks;
+	using System.Threading;
+	[TestFixture]
+	public class InvalidationTestsAsync : TestCase
+	{
+		protected override string MappingsAssembly => "NHibernate.Test";
+
+		protected override IList Mappings => new[] { "SecondLevelCacheTest.Item.hbm.xml" };
+
+		protected override void Configure(Configuration configuration)
+		{
+			configuration.SetProperty(Environment.CacheProvider, typeof(HashtableCacheProvider).AssemblyQualifiedName);
+			configuration.SetProperty(Environment.UseQueryCache, "true");
+		}
+
+		[Test]
+		public async Task InvalidatesEntitiesAsync()
+		{
+			var debugSessionFactory = (DebugSessionFactory) Sfi;
+
+			var cache = Substitute.For<UpdateTimestampsCache>(Sfi.Settings, new Dictionary<string, string>());
+
+			var updateTimestampsCacheField = typeof(SessionFactoryImpl).GetField(
+				"updateTimestampsCache",
+				BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
+
+			updateTimestampsCacheField.SetValue(debugSessionFactory.ActualFactory, cache);
+
+			//"Received" assertions can not be used since the collection is reused and cleared between calls.
+			//The received args are cloned and stored
+			var preInvalidations = new List<IReadOnlyCollection<string>>();
+			var invalidations = new List<IReadOnlyCollection<string>>();
+
+			await (cache.PreInvalidateAsync(Arg.Do<IReadOnlyCollection<string>>(x => preInvalidations.Add(x.ToList())), CancellationToken.None));
+			await (cache.InvalidateAsync(Arg.Do<IReadOnlyCollection<string>>(x => invalidations.Add(x.ToList())), CancellationToken.None));
+
+			using (var session = OpenSession())
+			{
+				using (var tx = session.BeginTransaction())
+				{
+					foreach (var i in Enumerable.Range(1, 10))
+					{
+						var item = new Item {Id = i};
+						await (session.SaveAsync(item));
+					}
+
+					await (tx.CommitAsync());
+				}
+
+				using (var tx = session.BeginTransaction())
+				{
+					foreach (var i in Enumerable.Range(1, 10))
+					{
+						var item = await (session.GetAsync<Item>(i));
+						item.Name = item.Id.ToString();
+					}
+
+					await (tx.CommitAsync());
+				}
+
+				using (var tx = session.BeginTransaction())
+				{
+					foreach (var i in Enumerable.Range(1, 10))
+					{
+						var item = await (session.GetAsync<Item>(i));
+						await (session.DeleteAsync(item));
+					}
+
+					await (tx.CommitAsync());
+				}
+			}
+
+			//Should receive one preinvalidation and one invalidation per commit
+			Assert.That(preInvalidations, Has.Count.EqualTo(3));
+			Assert.That(preInvalidations, Has.All.Count.EqualTo(1).And.Contains("Item"));
+
+			Assert.That(invalidations, Has.Count.EqualTo(3));
+			Assert.That(invalidations, Has.All.Count.EqualTo(1).And.Contains("Item"));
+		}
+
+		protected override void OnTearDown()
+		{
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				s.Delete("from Item");
+				tx.Commit();
+			}
+		}
+	}
+}

src/NHibernate.Test/SecondLevelCacheTest/InvalidationTests.cs

@@ -0,0 +1,102 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using NHibernate.Cache;
+using NHibernate.Cfg;
+using NHibernate.Impl;
+using NHibernate.Test.SecondLevelCacheTests;
+using NSubstitute;
+using NUnit.Framework;
+
+namespace NHibernate.Test.SecondLevelCacheTest
+{
+	[TestFixture]
+	public class InvalidationTests : TestCase
+	{
+		protected override string MappingsAssembly => "NHibernate.Test";
+
+		protected override IList Mappings => new[] { "SecondLevelCacheTest.Item.hbm.xml" };
+
+		protected override void Configure(Configuration configuration)
+		{
+			configuration.SetProperty(Environment.CacheProvider, typeof(HashtableCacheProvider).AssemblyQualifiedName);
+			configuration.SetProperty(Environment.UseQueryCache, "true");
+		}
+
+		[Test]
+		public void InvalidatesEntities()
+		{
+			var debugSessionFactory = (DebugSessionFactory) Sfi;
+
+			var cache = Substitute.For<UpdateTimestampsCache>(Sfi.Settings, new Dictionary<string, string>());
+
+			var updateTimestampsCacheField = typeof(SessionFactoryImpl).GetField(
+				"updateTimestampsCache",
+				BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
+
+			updateTimestampsCacheField.SetValue(debugSessionFactory.ActualFactory, cache);
+
+			//"Received" assertions can not be used since the collection is reused and cleared between calls.
+			//The received args are cloned and stored
+			var preInvalidations = new List<IReadOnlyCollection<string>>();
+			var invalidations = new List<IReadOnlyCollection<string>>();
+
+			cache.PreInvalidate(Arg.Do<IReadOnlyCollection<string>>(x => preInvalidations.Add(x.ToList())));
+			cache.Invalidate(Arg.Do<IReadOnlyCollection<string>>(x => invalidations.Add(x.ToList())));
+
+			using (var session = OpenSession())
+			{
+				using (var tx = session.BeginTransaction())
+				{
+					foreach (var i in Enumerable.Range(1, 10))
+					{
+						var item = new Item {Id = i};
+						session.Save(item);
+					}
+
+					tx.Commit();
+				}
+
+				using (var tx = session.BeginTransaction())
+				{
+					foreach (var i in Enumerable.Range(1, 10))
+					{
+						var item = session.Get<Item>(i);
+						item.Name = item.Id.ToString();
+					}
+
+					tx.Commit();
+				}
+
+				using (var tx = session.BeginTransaction())
+				{
+					foreach (var i in Enumerable.Range(1, 10))
+					{
+						var item = session.Get<Item>(i);
+						session.Delete(item);
+					}
+
+					tx.Commit();
+				}
+			}
+
+			//Should receive one preinvalidation and one invalidation per commit
+			Assert.That(preInvalidations, Has.Count.EqualTo(3));
+			Assert.That(preInvalidations, Has.All.Count.EqualTo(1).And.Contains("Item"));
+
+			Assert.That(invalidations, Has.Count.EqualTo(3));
+			Assert.That(invalidations, Has.All.Count.EqualTo(1).And.Contains("Item"));
+		}
+
+		protected override void OnTearDown()
+		{
+			using (var s = OpenSession())
+			using (var tx = s.BeginTransaction())
+			{
+				s.Delete("from Item");
+				tx.Commit();
+			}
+		}
+	}
+}

src/NHibernate/Async/Cache/UpdateTimestampsCache.cs

@@ -10,6 +10,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Runtime.CompilerServices;
 
 using NHibernate.Cfg;
@@ -24,7 +25,7 @@ public partial class UpdateTimestampsCache
 		private readonly NHibernate.Util.AsyncLock _invalidate = new NHibernate.Util.AsyncLock();
 		private readonly NHibernate.Util.AsyncLock _isUpToDate = new NHibernate.Util.AsyncLock();
 
-		public Task ClearAsync(CancellationToken cancellationToken)
+		public virtual Task ClearAsync(CancellationToken cancellationToken)
 		{
 			if (cancellationToken.IsCancellationRequested)
 			{
@@ -33,43 +34,82 @@ public Task ClearAsync(CancellationToken cancellationToken)
 			return updateTimestamps.ClearAsync(cancellationToken);
 		}
 
+		//Since v5.1
+		[Obsolete("Please use PreInvalidate(IReadOnlyCollection<string>) instead.")]
+		public Task PreInvalidateAsync(object[] spaces, CancellationToken cancellationToken)
+		{
+			if (cancellationToken.IsCancellationRequested)
+			{
+				return Task.FromCanceled<object>(cancellationToken);
+			}
+			try
+			{
+				//Only for backwards compatibility.
+				return PreInvalidateAsync(spaces.OfType<string>().ToList(), cancellationToken);
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
+		}
+
 		[MethodImpl()]
-		public async Task PreInvalidateAsync(object[] spaces, CancellationToken cancellationToken)
+		public virtual async Task PreInvalidateAsync(IReadOnlyCollection<string> spaces, CancellationToken cancellationToken)
 		{
 			cancellationToken.ThrowIfCancellationRequested();
 			using (await _preInvalidate.LockAsync())
 			{
 				//TODO: to handle concurrent writes correctly, this should return a Lock to the client
 				long ts = updateTimestamps.NextTimestamp() + updateTimestamps.Timeout;
-				for (int i = 0; i < spaces.Length; i++)
+				foreach (var space in spaces)
 				{
-					await (updateTimestamps.PutAsync(spaces[i], ts, cancellationToken)).ConfigureAwait(false);
+					await (updateTimestamps.PutAsync(space, ts, cancellationToken)).ConfigureAwait(false);
 				}
+
 				//TODO: return new Lock(ts);
 			}
+
 			//TODO: return new Lock(ts);
 		}
 
-		/// <summary></summary>
+		//Since v5.1
+		[Obsolete("Please use PreInvalidate(IReadOnlyCollection<string>) instead.")]
+		public Task InvalidateAsync(object[] spaces, CancellationToken cancellationToken)
+		{
+			if (cancellationToken.IsCancellationRequested)
+			{
+				return Task.FromCanceled<object>(cancellationToken);
+			}
+			try
+			{
+				//Only for backwards compatibility.
+				return InvalidateAsync(spaces.OfType<string>().ToList(), cancellationToken);
+			}
+			catch (Exception ex)
+			{
+				return Task.FromException<object>(ex);
+			}
+		}
+
 		[MethodImpl()]
-		public async Task InvalidateAsync(object[] spaces, CancellationToken cancellationToken)
+		public virtual async Task InvalidateAsync(IReadOnlyCollection<string> spaces, CancellationToken cancellationToken)
 		{
 			cancellationToken.ThrowIfCancellationRequested();
 			using (await _invalidate.LockAsync())
 			{
 				//TODO: to handle concurrent writes correctly, the client should pass in a Lock
 				long ts = updateTimestamps.NextTimestamp();
 				//TODO: if lock.getTimestamp().equals(ts)
-				for (int i = 0; i < spaces.Length; i++)
+				foreach (var space in spaces)
 				{
-					log.Debug("Invalidating space [{0}]", spaces[i]);
-					await (updateTimestamps.PutAsync(spaces[i], ts, cancellationToken)).ConfigureAwait(false);
+					log.Debug("Invalidating space [{0}]", space);
+					await (updateTimestamps.PutAsync(space, ts, cancellationToken)).ConfigureAwait(false);
 				}
 			}
 		}
 
 		[MethodImpl()]
-		public async Task<bool> IsUpToDateAsync(ISet<string> spaces, long timestamp /* H2.1 has Long here */, CancellationToken cancellationToken)
+		public virtual async Task<bool> IsUpToDateAsync(ISet<string> spaces, long timestamp /* H2.1 has Long here */, CancellationToken cancellationToken)
 		{
 			cancellationToken.ThrowIfCancellationRequested();
 			using (await _isUpToDate.LockAsync())