Refactor ForeignKeys.IsTransient & ForeignKeys.IsNotTransient to reduce async code generation

Author: hazzik

src/NHibernate/Collection/AbstractPersistentCollection.cs

@@ -714,7 +714,7 @@ protected virtual ICollection GetOrphans(ICollection oldElements, ICollection cu
 			var currentIds = new HashSet<TypedValue>();
 			foreach (object current in currentElements)
 			{
-				if (current != null && ForeignKeys.IsNotTransient(entityName, current, null, session))
+				if (current != null && ForeignKeys.IsNotTransientSlow(entityName, current, session))
 				{
 					object currentId = ForeignKeys.GetEntityIdentifierIfNotUnsaved(entityName, current, session);
 					currentIds.Add(new TypedValue(idType, currentId));
@@ -736,7 +736,7 @@ protected virtual ICollection GetOrphans(ICollection oldElements, ICollection cu
 
 		public void IdentityRemove(IList list, object obj, string entityName, ISessionImplementor session)
 		{
-			if (obj != null && ForeignKeys.IsNotTransient(entityName, obj, null, session))
+			if (obj != null && ForeignKeys.IsNotTransientSlow(entityName, obj, session))
 			{
 				IType idType = session.Factory.GetEntityPersister(entityName).IdentifierType;
 

src/NHibernate/Engine/CascadingAction.cs

@@ -343,7 +343,7 @@ public override void NoCascade(IEventSource session, object child, object parent
 				{
 					string childEntityName = ((EntityType)type).GetAssociatedEntityName(session.Factory);
 
-					if (!IsInManagedState(child, session) && !(child.IsProxy()) && ForeignKeys.IsTransient(childEntityName, child, null, session))
+					if (!IsInManagedState(child, session) && !child.IsProxy() && ForeignKeys.IsTransientSlow(childEntityName, child, session))
 					{
 						string parentEntiytName = persister.EntityName;
 						string propertyName = persister.PropertyNames[propertyIndex];

src/NHibernate/Engine/ForeignKeys.cs

@@ -138,7 +138,7 @@ private bool IsNullifiable(string entityName, object obj)
 				EntityEntry entityEntry = session.PersistenceContext.GetEntry(obj);
 				if (entityEntry == null)
 				{
-					return IsTransient(entityName, obj, null, session);
+					return IsTransientSlow(entityName, obj, session);
 				}
 				else
 				{
@@ -151,31 +151,25 @@ private bool IsNullifiable(string entityName, object obj)
 		/// Is this instance persistent or detached?
 		/// </summary>
 		/// <remarks>
-		/// If <paramref name="assumed"/> is non-null, don't hit the database to make the 
-		/// determination, instead assume that value; the client code must be 
-		/// prepared to "recover" in the case that this assumed result is incorrect.
+		/// Hit the database to make the determination.
 		/// </remarks>
-		public static bool IsNotTransient(string entityName, System.Object entity, bool? assumed, ISessionImplementor session)
+		public static bool IsNotTransientSlow(string entityName, object entity, ISessionImplementor session)
 		{
 			if (entity.IsProxy())
 				return true;
 			if (session.PersistenceContext.IsEntryFor(entity))
 				return true;
-			return !IsTransient(entityName, entity, assumed, session);
+			return !IsTransientSlow(entityName, entity, session);
 		}
 
 		/// <summary> 
 		/// Is this instance, which we know is not persistent, actually transient? 
-		/// If <tt>assumed</tt> is non-null, don't hit the database to make the 
-		/// determination, instead assume that value; the client code must be 
-		/// prepared to "recover" in the case that this assumed result is incorrect.
+		/// Don't hit the database to make the determination, instead return null; 
 		/// </summary>
 		/// <remarks>
-		/// If <paramref name="assumed"/> is non-null, don't hit the database to make the 
-		/// determination, instead assume that value; the client code must be 
-		/// prepared to "recover" in the case that this assumed result is incorrect.
+		/// Don't hit the database to make the determination, instead return null; 
 		/// </remarks>
-		public static bool IsTransient(string entityName, object entity, bool? assumed, ISessionImplementor session)
+		public static bool? IsTransientFast(string entityName, object entity, ISessionImplementor session)
 		{
 			if (Equals(Intercept.LazyPropertyInitializer.UnfetchedProperty, entity))
 			{
@@ -185,27 +179,33 @@ public static bool IsTransient(string entityName, object entity, bool? assumed,
 			}
 
 			// let the interceptor inspect the instance to decide
-			bool? isUnsaved = session.Interceptor.IsTransient(entity);
-			if (isUnsaved.HasValue)
-				return isUnsaved.Value;
-
 			// let the persister inspect the instance to decide
-			IEntityPersister persister = session.GetEntityPersister(entityName, entity);
-			isUnsaved = persister.IsTransient(entity, session);
-			if (isUnsaved.HasValue)
-				return isUnsaved.Value;
+			return session.Interceptor.IsTransient(entity) ??
+			       session.GetEntityPersister(entityName, entity).IsTransient(entity, session);
+		}
 
-			// we use the assumed value, if there is one, to avoid hitting
-			// the database
-			if (assumed.HasValue)
-				return assumed.Value;
+		/// <summary> 
+		/// Is this instance, which we know is not persistent, actually transient? 
+		/// </summary>
+		/// <remarks>
+		/// Hit the database to make the determination.
+		/// </remarks>
+		public static bool IsTransientSlow(string entityName, object entity, ISessionImplementor session)
+		{
+			return IsTransientFast(entityName, entity, session) ??
+			       HasDbSnapshot(entityName, entity, session);
+		}
 
+		static bool HasDbSnapshot(string entityName, object entity, ISessionImplementor session)
+		{
+			IEntityPersister persister = session.GetEntityPersister(entityName, entity);
 			if (persister.IdentifierGenerator is Assigned)
 			{
 				// When using assigned identifiers we cannot tell if an entity
 				// is transient or detached without querying the database.
 				// This could potentially cause Select N+1 in cascaded saves, so warn the user.
-				log.Warn("Unable to determine if " + entity.ToString()
+				log.Warn(
+					"Unable to determine if " + entity.ToString()
 					+ " with assigned identifier " + persister.GetIdentifier(entity)
 					+ " is transient or detached; querying the database."
 					+ " Use explicit Save() or Update() in session to prevent this.");
@@ -247,7 +247,7 @@ public static object GetEntityIdentifierIfNotUnsaved(string entityName, object e
 						return entity;
 					/**********************************************/
 
-					if (IsTransient(entityName, entity, false, session))
+					if (IsTransientFast(entityName, entity, session).GetValueOrDefault())
 					{
 						/***********************************************/
 						// TODO NH verify the behavior of NH607 test

src/NHibernate/Event/Default/AbstractSaveEventListener.cs

@@ -422,7 +422,10 @@ protected virtual EntityState GetEntityState(object entity, string entityName, E
 				//the object is transient or detached
 				//the entity is not associated with the session, so
 				//try interceptor and unsaved-value
-				if (ForeignKeys.IsTransient(entityName, entity, AssumedUnsaved, source))
+				var assumed = AssumedUnsaved;
+				if (assumed.HasValue
+					? ForeignKeys.IsTransientFast(entityName, entity, source).GetValueOrDefault(assumed.Value)
+					: ForeignKeys.IsTransientSlow(entityName, entity, source))
 				{
 					if (log.IsDebugEnabled)
 					{

src/NHibernate/Event/Default/DefaultDeleteEventListener.cs

@@ -45,8 +45,8 @@ public virtual void OnDelete(DeleteEvent @event, ISet<object> transientEntities)
 				log.Debug("entity was not persistent in delete processing");
 
 				persister = source.GetEntityPersister(@event.EntityName, entity);
-				
-				if (ForeignKeys.IsTransient(persister.EntityName, entity, null, source))
+
+				if (ForeignKeys.IsTransientSlow(persister.EntityName, entity, source))
 				{
 					DeleteTransientEntity(source, entity, @event.CascadeDeleteEnabled, persister, transientEntities);
 					// EARLY EXIT!!!

src/NHibernate/Event/Default/DefaultLockEventListener.cs

@@ -1,6 +1,7 @@
 using System;
 using NHibernate.Engine;
 using NHibernate.Persister.Entity;
+using NHibernate.Proxy;
 
 namespace NHibernate.Event.Default
 {
@@ -42,7 +43,7 @@ public virtual void OnLock(LockEvent @event)
 			{
 				IEntityPersister persister = source.GetEntityPersister(@event.EntityName, entity);
 				object id = persister.GetIdentifier(entity);
-				if (!ForeignKeys.IsNotTransient(@event.EntityName, entity, false, source))
+				if (ForeignKeys.IsTransientFast(@event.EntityName, entity, source).GetValueOrDefault())
 				{
 					throw new TransientObjectException("cannot lock an unsaved transient instance: " + persister.EntityName);
 				}

src/NHibernate/Event/Default/DefaultRefreshEventListener.cs

@@ -118,7 +118,7 @@ public virtual void OnRefresh(RefreshEvent @event, IDictionary refreshedAlready)
 
 			// NH Different behavior : we are ignoring transient entities without throw any kind of exception
 			// because a transient entity is "self refreshed"
-			if (!ForeignKeys.IsTransient(persister.EntityName, obj, result == null, @event.Session))
+			if (!ForeignKeys.IsTransientFast(persister.EntityName, obj, @event.Session).GetValueOrDefault(result == null))
 				UnresolvableObjectException.ThrowIfNull(result, id, persister.EntityName);
 		}
 

src/NHibernate/Type/EntityType.cs

@@ -239,7 +239,7 @@ public override object Replace(object original, object target, ISessionImplement
 				{
 					return target;
 				}
-				if (session.GetContextEntityIdentifier(original) == null && ForeignKeys.IsTransient(associatedEntityName, original, false, session))
+				if (session.GetContextEntityIdentifier(original) == null && ForeignKeys.IsTransientFast(associatedEntityName, original, session).GetValueOrDefault())
 				{
 					object copy = session.Factory.GetEntityPersister(associatedEntityName).Instantiate(null);
 					//TODO: should this be Session.instantiate(Persister, ...)?