fixup! Support IdBag in select id generator

Refactor the resulting code

Author: fredericDelaporte

src/NHibernate/Async/Id/IPostInsertIdentityPersister.cs

@@ -0,0 +1,47 @@
+//------------------------------------------------------------------------------
+// <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;
+using System.Data.Common;
+using System.Linq;
+using NHibernate.Engine;
+using NHibernate.Id.Insert;
+using NHibernate.Persister.Collection;
+using NHibernate.Persister.Entity;
+using NHibernate.SqlCommand;
+using NHibernate.Type;
+
+namespace NHibernate.Id
+{
+	using System.Threading.Tasks;
+	using System.Threading;
+
+	public partial interface ICompositeKeyPostInsertIdentityPersister
+	{
+
+		/// <summary>
+		/// Bind the parameter values of a SQL select command that performs a select based on an unique key.
+		/// </summary>
+		/// <param name="session">The current <see cref="ISession" />.</param>
+		/// <param name="selectCommand">The command.</param>
+		/// <param name="binder">The id insertion binder.</param>
+		/// <param name="suppliedPropertyNames">The names of the properties which map to the column(s) to use
+		/// in the select statement restriction. If supplied, they override the persister logic for determining
+		/// them.</param>
+		/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
+		/// <exception cref="NotSupportedException">thrown if <paramref name="suppliedPropertyNames"/> are
+		/// specified on a persister which does not allow a custom key.</exception>
+		Task BindSelectByUniqueKeyAsync(
+			ISessionImplementor session,
+			DbCommand selectCommand,
+			IBinder binder,
+			string[] suppliedPropertyNames, CancellationToken cancellationToken);
+	}
+}

src/NHibernate/Async/Id/SelectGenerator.cs

@@ -14,7 +14,6 @@
 using System.Linq;
 using NHibernate.Engine;
 using NHibernate.Id.Insert;
-using NHibernate.Persister.Collection;
 using NHibernate.Persister.Entity;
 using NHibernate.SqlCommand;
 using NHibernate.SqlTypes;
@@ -37,46 +36,47 @@ public partial class SelectGeneratorDelegate : AbstractSelectingDelegate
 			protected internal override async Task BindParametersAsync(ISessionImplementor session, DbCommand ps, object entity, CancellationToken cancellationToken)
 			{
 				cancellationToken.ThrowIfCancellationRequested();
+				var entityPersister = (IEntityPersister) persister;
+				var uniqueKeyPropertyNames = uniqueKeySuppliedPropertyNames ??
+					PostInsertIdentityPersisterExtension.DetermineNameOfPropertiesToUse(entityPersister);
 				for (var i = 0; i < uniqueKeyPropertyNames.Length; i++)
 				{
 					var uniqueKeyValue = entityPersister.GetPropertyValue(entity, uniqueKeyPropertyNames[i]);
 					await (uniqueKeyTypes[i].NullSafeSetAsync(ps, uniqueKeyValue, i, session, cancellationToken)).ConfigureAwait(false);
 				}
 			}
 
-			protected internal override Task BindParametersAsync(ISessionImplementor session, DbCommand ps, IBinder binder, CancellationToken cancellationToken)
+			protected internal override async Task BindParametersAsync(ISessionImplementor session, DbCommand ps, IBinder binder, CancellationToken cancellationToken)
 			{
-				if (cancellationToken.IsCancellationRequested)
-				{
-					return Task.FromCanceled<object>(cancellationToken);
-				}
-				try
+				cancellationToken.ThrowIfCancellationRequested();
+				// 6.0 TODO: remove the "if" block and do the other TODO of this method
+				if (persister is IEntityPersister)
 				{
-					if (entityPersister != null)
-					{
-						// 6.0 TODO: inline the call.
 #pragma warning disable 618
-						return BindParametersAsync(session, ps, binder.Entity, cancellationToken);
+					await (BindParametersAsync(session, ps, binder.Entity, cancellationToken)).ConfigureAwait(false);
 #pragma warning restore 618
-					}
-					else
-					{
-						return binder.BindValuesAsync(ps, cancellationToken);
-					}
+					return;
 				}
-				catch (Exception ex)
+
+				if (persister is ICompositeKeyPostInsertIdentityPersister multiProperties)
 				{
-					return Task.FromException<object>(ex);
+					await (multiProperties.BindSelectByUniqueKeyAsync(session, ps, binder, uniqueKeySuppliedPropertyNames, cancellationToken)).ConfigureAwait(false);
+					return;
 				}
+
+				// 6.0 TODO: remove by merging ICompositeKeyPostInsertIdentityPersister in IPostInsertIdentityPersister
+				await (binder.BindValuesAsync(ps, cancellationToken)).ConfigureAwait(false);
 			}
 
 			protected internal override async Task<object> GetResultAsync(ISessionImplementor session, DbDataReader rs, object entity, CancellationToken cancellationToken)
 			{
 				cancellationToken.ThrowIfCancellationRequested();
 				if (!await (rs.ReadAsync(cancellationToken)).ConfigureAwait(false))
 				{
-					throw new IdentifierGenerationException(
-						$"The inserted row could not be located by the unique key: {string.Join(", ", uniqueKeyPropertyNames)}");
+					var message = "The inserted row could not be located by the unique key";
+					if (uniqueKeySuppliedPropertyNames != null)
+						message = $"{message} (supplied unique key: {string.Join(", ", uniqueKeySuppliedPropertyNames)})";
+					throw new IdentifierGenerationException(message);
 				}
 				return await (idType.NullSafeGetAsync(rs, persister.RootTableKeyColumnNames, session, entity, cancellationToken)).ConfigureAwait(false);
 			}

src/NHibernate/Async/Persister/Collection/AbstractCollectionPersister.cs

@@ -540,6 +540,21 @@ protected async Task<object> PerformInsertAsync(object ownerId, IPersistentColle
 
 		#region NH specific
 
+		#region IPostInsertIdentityPersister Members
+
+		public Task BindSelectByUniqueKeyAsync(
+			ISessionImplementor session,
+			DbCommand selectCommand,
+			IBinder binder,
+			string[] suppliedPropertyNames, CancellationToken cancellationToken)
+		{
+			if (cancellationToken.IsCancellationRequested)
+			{
+				return Task.FromCanceled<object>(cancellationToken);
+			}
+			return binder.BindValuesAsync(selectCommand, cancellationToken);
+		}
+		#endregion
 
 		/// <summary>
 		/// Perform an SQL INSERT, and then retrieve a generated identifier.

src/NHibernate/Async/Persister/Entity/AbstractEntityPersister.cs

@@ -455,6 +455,23 @@ protected Task<object> InsertAsync(object[] fields, bool[] notNull, SqlCommandIn
 			}
 		}
 
+		public async Task BindSelectByUniqueKeyAsync(
+			ISessionImplementor session,
+			DbCommand selectCommand,
+			IBinder binder,
+			string[] suppliedPropertyNames, CancellationToken cancellationToken)
+		{
+			cancellationToken.ThrowIfCancellationRequested();
+			var propertyNames = GetUniqueKeyPropertyNames(suppliedPropertyNames);
+			var parameterTypes = propertyNames.Select(GetPropertyType).ToArray();
+			var entity = binder.Entity;
+			for (var i = 0; i < propertyNames.Length; i++)
+			{
+				var uniqueKeyValue = GetPropertyValue(entity, propertyNames[i]);
+				await (parameterTypes[i].NullSafeSetAsync(selectCommand, uniqueKeyValue, i, session, cancellationToken)).ConfigureAwait(false);
+			}
+		}
+
 		/// <summary>
 		/// Perform an SQL INSERT.
 		/// </summary>

src/NHibernate/Id/IPostInsertIdentityPersister.cs

@@ -1,4 +1,10 @@
 using System;
+using System.Data.Common;
+using System.Linq;
+using NHibernate.Engine;
+using NHibernate.Id.Insert;
+using NHibernate.Persister.Collection;
+using NHibernate.Persister.Entity;
 using NHibernate.SqlCommand;
 using NHibernate.Type;
 
@@ -9,22 +15,65 @@ internal static class PostInsertIdentityPersisterExtension
 	{
 		public static SqlString GetSelectByUniqueKeyString(
 			this IPostInsertIdentityPersister persister,
-			string[] propertyNames)
+			string[] suppliedPropertyNames,
+			out IType[] parameterTypes)
 		{
 			if (persister is ICompositeKeyPostInsertIdentityPersister multiProperties)
-				return multiProperties.GetSelectByUniqueKeyString(propertyNames);
+				return multiProperties.GetSelectByUniqueKeyString(suppliedPropertyNames, out parameterTypes);
 
-			if (propertyNames.Length > 1)
+			if (suppliedPropertyNames.Length > 1)
 			{
 				throw new IdentifierGenerationException(
 					$"persister {persister} does not implement {nameof(ICompositeKeyPostInsertIdentityPersister)}, " +
 					$"which is required for selecting by an unique key spanning multiple properties.");
 			}
 
+			if (persister is IEntityPersister entityPersister)
+			{
+				var uniqueKeyPropertyNames = suppliedPropertyNames ?? DetermineNameOfPropertiesToUse(entityPersister);
+
+				parameterTypes = uniqueKeyPropertyNames.Select(p => entityPersister.GetPropertyType(p)).ToArray();
+			}
+			else if (persister is IQueryableCollection collectionPersister)
+			{
+				parameterTypes = new[] { collectionPersister.KeyType, collectionPersister.ElementType };
+			}
+			else 
+			{
+				throw new IdentifierGenerationException(
+					$"Persister type {persister.GetType()} is not supported by post insert identity persisters");
+			}
 #pragma warning disable 618
-			return persister.GetSelectByUniqueKeyString(propertyNames[0]);
+			return persister.GetSelectByUniqueKeyString(suppliedPropertyNames[0]);
 #pragma warning restore 618
 		}
+
+		internal static string[] DetermineNameOfPropertiesToUse(IEntityPersister persister)
+		{
+			var naturalIdPropertyIndices = persister.NaturalIdentifierProperties;
+			if (naturalIdPropertyIndices == null)
+			{
+				throw new IdentifierGenerationException(
+					"no natural-id property defined; need to specify [key] in generator parameters");
+			}
+
+			foreach (var naturalIdPropertyIndex in naturalIdPropertyIndices)
+			{
+				var inclusion = persister.PropertyInsertGenerationInclusions[naturalIdPropertyIndex];
+				if (inclusion != ValueInclusion.None)
+				{
+					throw new IdentifierGenerationException(
+						"natural-id also defined as insert-generated; need to specify [key] in generator parameters");
+				}
+			}
+
+			var result = new string[naturalIdPropertyIndices.Length];
+			for (var i = 0; i < naturalIdPropertyIndices.Length; i++)
+			{
+				result[i] = persister.PropertyNames[naturalIdPropertyIndices[i]];
+			}
+			return result;
+		}
 	}
 
 	/// <summary> 
@@ -56,7 +105,7 @@ public interface IPostInsertIdentityPersister
 		/// </param>
 		/// <returns> The SQL select string </returns>
 		// Since 5.2
-		[Obsolete("Have the persister implement IMultiPropertiesPostInsertIdentityPersister and use its GetSelectByUniqueKeyString(string[] propertyNames).")]
+		[Obsolete("Have the persister implement IMultiPropertiesPostInsertIdentityPersister and use its GetSelectByUniqueKeyString(string[] suppliedPropertyNames, out IType[] parameterTypes).")]
 		SqlString GetSelectByUniqueKeyString(string propertyName);
 
 		#region NH specific
@@ -74,17 +123,36 @@ public interface IPostInsertIdentityPersister
 	/// An <see cref="IPostInsertIdentityPersister" /> that supports selecting by an unique key spanning
 	/// multiple properties.
 	/// </summary>
-	public interface ICompositeKeyPostInsertIdentityPersister
+	public partial interface ICompositeKeyPostInsertIdentityPersister
 	{
 		/// <summary>
-		/// Get a SQL select string that performs a select based on a unique
-		/// key determined by the given array of property names.
+		/// Get a SQL select string that performs a select based on an unique key, optionnaly determined by
+		/// the given array of property names.
 		/// </summary>
-		/// <param name="propertyNames">
-		/// The names of the properties which map to the
-		/// column(s) to use in the select statement restriction.
-		/// </param>
+		/// <param name="suppliedPropertyNames">The names of the properties which map to the column(s) to use
+		/// in the select statement restriction. If supplied, they override the persister logic for determining
+		/// them.</param>
+		/// <param name="parameterTypes">In return, the parameter types used by the select string.</param>
 		/// <returns>The SQL select string.</returns>
-		SqlString GetSelectByUniqueKeyString(string[] propertyNames);
+		/// <exception cref="NotSupportedException">thrown if <paramref name="suppliedPropertyNames"/> are
+		/// specified on a persister which does not allow a custom key.</exception>
+		SqlString GetSelectByUniqueKeyString(string[] suppliedPropertyNames, out IType[] parameterTypes);
+
+		/// <summary>
+		/// Bind the parameter values of a SQL select command that performs a select based on an unique key.
+		/// </summary>
+		/// <param name="session">The current <see cref="ISession" />.</param>
+		/// <param name="selectCommand">The command.</param>
+		/// <param name="binder">The id insertion binder.</param>
+		/// <param name="suppliedPropertyNames">The names of the properties which map to the column(s) to use
+		/// in the select statement restriction. If supplied, they override the persister logic for determining
+		/// them.</param>
+		/// <exception cref="NotSupportedException">thrown if <paramref name="suppliedPropertyNames"/> are
+		/// specified on a persister which does not allow a custom key.</exception>
+		void BindSelectByUniqueKey(
+			ISessionImplementor session,
+			DbCommand selectCommand,
+			IBinder binder,
+			string[] suppliedPropertyNames);
 	}
 }