Fix using Criteria and QuerOver for NH-3848

itmagination · hazzik · commit 7d53824ba746 · 2018-05-25T14:16:43.000+12:00
diff --git a/src/NHibernate/Engine/Loading/CollectionLoadContext.cs b/src/NHibernate/Engine/Loading/CollectionLoadContext.cs
@@ -144,7 +144,8 @@ public IPersistentCollection GetLoadingCollection(ICollectionPersister persister
 		/// complete. 
 		/// </summary>
 		/// <param name="persister">The persister for which to complete loading. </param>
-		public void EndLoadingCollections(ICollectionPersister persister)
+        /// <param name="canAddCollectionsToCache">Indicates if collcetion can be put in cache</param>
+        public void EndLoadingCollections(ICollectionPersister persister, bool canAddCollectionsToCache)
 		{
 			if (!loadContexts.HasLoadingCollectionEntries && (localLoadingCollectionKeys.Count == 0))
 			{
@@ -189,7 +190,7 @@ public void EndLoadingCollections(ICollectionPersister persister)
 			}
 			localLoadingCollectionKeys.ExceptWith(toRemove);
 
-			EndLoadingCollections(persister, matches);
+            EndLoadingCollections(persister, matches, canAddCollectionsToCache);
 			if ((localLoadingCollectionKeys.Count == 0))
 			{
 				// todo : hack!!!
@@ -202,7 +203,7 @@ public void EndLoadingCollections(ICollectionPersister persister)
 			}
 		}
 
-		private void EndLoadingCollections(ICollectionPersister persister, IList<LoadingCollectionEntry> matchedCollectionEntries)
+        private void EndLoadingCollections(ICollectionPersister persister, IList<LoadingCollectionEntry> matchedCollectionEntries, bool canAddCollectionsToCache)
 		{
 			if (matchedCollectionEntries == null || matchedCollectionEntries.Count == 0)
 			{
@@ -221,7 +222,7 @@ private void EndLoadingCollections(ICollectionPersister persister, IList<Loading
 
 			for (int i = 0; i < count; i++)
 			{
-				EndLoadingCollection(matchedCollectionEntries[i], persister);
+                EndLoadingCollection(matchedCollectionEntries[i], persister, canAddCollectionsToCache);
 			}
 
 			if (log.IsDebugEnabled())
@@ -230,7 +231,7 @@ private void EndLoadingCollections(ICollectionPersister persister, IList<Loading
 			}
 		}
 
-		private void EndLoadingCollection(LoadingCollectionEntry lce, ICollectionPersister persister)
+        private void EndLoadingCollection(LoadingCollectionEntry lce, ICollectionPersister persister, bool canAddCollectionsToCache)
 		{
 			if (log.IsDebugEnabled())
 			{
@@ -264,7 +265,7 @@ private void EndLoadingCollection(LoadingCollectionEntry lce, ICollectionPersist
 				ce.PostInitialize(lce.Collection, persistenceContext);
 			}
 
-			bool addToCache = hasNoQueuedAdds && persister.HasCache && 
+            bool addToCache = canAddCollectionsToCache && hasNoQueuedAdds && persister.HasCache && 
 				session.CacheMode.HasFlag(CacheMode.Put) && !ce.IsDoremove; // and this is not a forced initialization during flush
 
 			if (addToCache)
diff --git a/src/NHibernate/Engine/QueryParameters.cs b/src/NHibernate/Engine/QueryParameters.cs
@@ -38,28 +38,28 @@ public QueryParameters(IType[] positionalParameterTypes, object[] postionalParam
 			: this(positionalParameterTypes, postionalParameterValues, null, collectionKeys) {}
 
 		public QueryParameters(IType[] positionalParameterTypes, object[] postionalParameterValues, IDictionary<string, TypedValue> namedParameters, object[] collectionKeys)
-			: this(positionalParameterTypes, postionalParameterValues, namedParameters, null, null, false, false, false, null, null, collectionKeys, null) {}
+			: this(positionalParameterTypes, postionalParameterValues, namedParameters, null, null, false, false, false, null, null, collectionKeys, null, true) {}
 
 		public QueryParameters(IType[] positionalParameterTypes, object[] positionalParameterValues, IDictionary<string, LockMode> lockModes, RowSelection rowSelection,
 		                       bool isReadOnlyInitialized, bool readOnly, bool cacheable, string cacheRegion, string comment, bool isLookupByNaturalKey, IResultTransformer transformer)
-			: this(positionalParameterTypes, positionalParameterValues, null, lockModes, rowSelection, isReadOnlyInitialized, readOnly, cacheable, cacheRegion, comment, null, transformer)
+			: this(positionalParameterTypes, positionalParameterValues, null, lockModes, rowSelection, isReadOnlyInitialized, readOnly, cacheable, cacheRegion, comment, null, transformer, true)
 		{
 			NaturalKeyLookup = isLookupByNaturalKey;
 		}
 
 		public QueryParameters(IDictionary<string, TypedValue> namedParameters, IDictionary<string, LockMode> lockModes, RowSelection rowSelection, bool isReadOnlyInitialized,
-		                       bool readOnly, bool cacheable, string cacheRegion, string comment, bool isLookupByNaturalKey, IResultTransformer transformer)
+		                       bool readOnly, bool cacheable, string cacheRegion, string comment, bool isLookupByNaturalKey, IResultTransformer transformer, bool canAddCollectionsToCache)
 			: this(
 				TypeHelper.EmptyTypeArray, Array.Empty<object>(), namedParameters, lockModes, rowSelection, isReadOnlyInitialized, readOnly, cacheable, cacheRegion, comment, null,
-				transformer)
+                transformer, canAddCollectionsToCache)
 		{
 			// used by CriteriaTranslator
 			NaturalKeyLookup = isLookupByNaturalKey;
 		}
 
 		public QueryParameters(IType[] positionalParameterTypes, object[] positionalParameterValues, IDictionary<string, TypedValue> namedParameters,
 		                       IDictionary<string, LockMode> lockModes, RowSelection rowSelection, bool isReadOnlyInitialized, bool readOnly, bool cacheable, string cacheRegion,
-		                       string comment, object[] collectionKeys, IResultTransformer transformer)
+                               string comment, object[] collectionKeys, IResultTransformer transformer, bool canAddCollectionsToCache)
 		{
 			PositionalParameterTypes = positionalParameterTypes ?? Array.Empty<IType>();
 			PositionalParameterValues = positionalParameterValues ?? Array.Empty<object>();
@@ -73,14 +73,15 @@ public QueryParameters(IType[] positionalParameterTypes, object[] positionalPara
 			IsReadOnlyInitialized = isReadOnlyInitialized;
 			this.readOnly = readOnly;
 			ResultTransformer = transformer;
+		    CanAddCollectionsToCache = canAddCollectionsToCache;
 		}
 
 		public QueryParameters(IType[] positionalParameterTypes, object[] positionalParameterValues, IDictionary<string, TypedValue> namedParameters,
 		                       IDictionary<string, LockMode> lockModes, RowSelection rowSelection, bool isReadOnlyInitialized, bool readOnly, bool cacheable, string cacheRegion,
 		                       string comment, object[] collectionKeys, object optionalObject, string optionalEntityName, object optionalId, IResultTransformer transformer)
 			: this(
 				positionalParameterTypes, positionalParameterValues, namedParameters, lockModes, rowSelection, isReadOnlyInitialized, readOnly, cacheable, cacheRegion, comment, collectionKeys,
-				transformer)
+				transformer, true)
 		{
 			OptionalEntityName = optionalEntityName;
 			OptionalId = optionalId;
@@ -138,6 +139,11 @@ public bool HasRowSelection
 
 		public bool Callable { get; set; }
 
+        /// <summary>
+        /// Indicates if we can add loaded child collections to second lvl cache.
+        /// </summary>
+        public bool CanAddCollectionsToCache { get; set; }
+
 		public bool ReadOnly
 		{
 			get
diff --git a/src/NHibernate/Impl/CriteriaImpl.cs b/src/NHibernate/Impl/CriteriaImpl.cs
@@ -687,6 +687,7 @@ public sealed partial class Subcriteria : ICriteria, ISupportSelectModeCriteria
 			private LockMode lockMode;
 			private readonly JoinType joinType;
 			private ICriterion withClause;
+			private bool hasRestrictions;
 
 			internal Subcriteria(CriteriaImpl root, ICriteria parent, string path, string alias, JoinType joinType, ICriterion withClause, string joinEntityName = null)
 			{
@@ -697,6 +698,7 @@ internal Subcriteria(CriteriaImpl root, ICriteria parent, string path, string al
 				this.joinType = joinType;
 				this.withClause = withClause;
 				JoinEntityName = joinEntityName;
+			    hasRestrictions = withClause != null;
 
 				root.subcriteriaList.Add(this);
 
@@ -730,6 +732,11 @@ public string Path
 				get { return path; }
 			}
 
+		    public bool HasRestrictions
+		    {
+		        get { return hasRestrictions; }
+		    }
+
 			public ICriteria Parent
 			{
 				get { return parent; }
@@ -769,6 +776,7 @@ public ICriteria SetLockMode(LockMode lockMode)
 
 			public ICriteria Add(ICriterion expression)
 			{
+			    hasRestrictions = true;
 				root.Add(this, expression);
 				return this;
 			}
diff --git a/src/NHibernate/Impl/MultiCriteriaImpl.cs b/src/NHibernate/Impl/MultiCriteriaImpl.cs
@@ -267,7 +267,7 @@ private void GetResultsFromDatabase(IList results)
 					for (int i = 0; i < loaders.Count; i++)
 					{
 						CriteriaLoader loader = loaders[i];
-						loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, session.DefaultReadOnly);
+                        loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, session.DefaultReadOnly, parameters[i].CanAddCollectionsToCache);
 
 						if (createSubselects[i])
 						{
diff --git a/src/NHibernate/Impl/MultiQueryImpl.cs b/src/NHibernate/Impl/MultiQueryImpl.cs
@@ -606,7 +606,7 @@ protected List<object> DoList()
 						ITranslator translator = translators[i];
 						QueryParameters parameter = parameters[i];
 
-						translator.Loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, false);
+                        translator.Loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, false, parameters[i].CanAddCollectionsToCache);
 
 						if (createSubselects[i])
 						{
diff --git a/src/NHibernate/Loader/Criteria/CriteriaLoader.cs b/src/NHibernate/Loader/Criteria/CriteriaLoader.cs
@@ -94,7 +94,7 @@ protected override bool IsChildFetchEntity(int i)
 
 		public IList List(ISessionImplementor session)
 		{
-			return List(session, translator.GetQueryParameters(), querySpaces);
+            return List(session, translator.GetQueryParameters(), querySpaces);
 		}
 
 		protected override IResultTransformer ResolveResultTransformer(IResultTransformer resultTransformer)
diff --git a/src/NHibernate/Loader/Criteria/CriteriaQueryTranslator.cs b/src/NHibernate/Loader/Criteria/CriteriaQueryTranslator.cs
@@ -139,6 +139,7 @@ public QueryParameters GetQueryParameters()
 			selection.FetchSize = rootCriteria.FetchSize;
 
 			var lockModes = new Dictionary<string, LockMode>();
+		    var canAddCollectionsToCache = true;
 			foreach (KeyValuePair<string, LockMode> me in rootCriteria.LockModes)
 			{
 				ICriteria subcriteria = GetAliasedCriteria(me.Key);
@@ -152,6 +153,9 @@ public QueryParameters GetQueryParameters()
 				{
 					lockModes[GetSQLAlias(subcriteria)] = lm;
 				}
+
+                if (subcriteria.HasRestrictions && subcriteria.JoinType == JoinType.LeftOuterJoin)
+                    canAddCollectionsToCache = false;
 			}
 			
 			IDictionary<string, TypedValue> queryNamedParameters = CollectedParameters.ToDictionary(np => np.Name, np => new TypedValue(np.Type, np.Value));
@@ -167,7 +171,8 @@ public QueryParameters GetQueryParameters()
 					rootCriteria.CacheRegion,
 					rootCriteria.Comment,
 					rootCriteria.LookupByNaturalKey,
-					rootCriteria.ResultTransformer);
+					rootCriteria.ResultTransformer,
+                    canAddCollectionsToCache);
 		}
 		
 		public SqlString GetGroupBy()
diff --git a/src/NHibernate/Loader/Loader.cs b/src/NHibernate/Loader/Loader.cs
@@ -310,7 +310,7 @@ protected object LoadSingleRow(DbDataReader resultSet, ISessionImplementor sessi
 												 queryParameters.NamedParameters);
 			}
 
-			InitializeEntitiesAndCollections(hydratedObjects, resultSet, session, queryParameters.IsReadOnly(session));
+            InitializeEntitiesAndCollections(hydratedObjects, resultSet, session, queryParameters.IsReadOnly(session), queryParameters.CanAddCollectionsToCache);
 			session.PersistenceContext.InitializeNonLazyCollections();
 			return result;
 		}
@@ -512,7 +512,7 @@ private IList DoQuery(ISessionImplementor session, QueryParameters queryParamete
 					session.Batcher.CloseCommand(st, rs);
 				}
 
-				InitializeEntitiesAndCollections(hydratedObjects, rs, session, queryParameters.IsReadOnly(session));
+                InitializeEntitiesAndCollections(hydratedObjects, rs, session, queryParameters.IsReadOnly(session), queryParameters.CanAddCollectionsToCache);
 
 				if (createSubselects)
 				{
@@ -594,7 +594,7 @@ private IEnumerable<SubselectFetch> CreateSubselects(IList<EntityKey[]> keys, Qu
 			}
 		}
 
-		internal void InitializeEntitiesAndCollections(IList hydratedObjects, object resultSetId, ISessionImplementor session, bool readOnly)
+        internal void InitializeEntitiesAndCollections(IList hydratedObjects, object resultSetId, ISessionImplementor session, bool readOnly, bool canAddCollectionsToCache)
 		{
 			ICollectionPersister[] collectionPersisters = CollectionPersisters;
 			if (collectionPersisters != null)
@@ -608,7 +608,7 @@ internal void InitializeEntitiesAndCollections(IList hydratedObjects, object res
 						//during loading
 						//TODO: or we could do this polymorphically, and have two
 						//      different operations implemented differently for arrays
-						EndCollectionLoad(resultSetId, session, collectionPersisters[i]);
+                        EndCollectionLoad(resultSetId, session, collectionPersisters[i], canAddCollectionsToCache);
 					}
 				}
 			}
@@ -652,17 +652,17 @@ internal void InitializeEntitiesAndCollections(IList hydratedObjects, object res
 						//the entities, since we might call hashCode() on the elements
 						//TODO: or we could do this polymorphically, and have two
 						//      different operations implemented differently for arrays
-						EndCollectionLoad(resultSetId, session, collectionPersisters[i]);
+                        EndCollectionLoad(resultSetId, session, collectionPersisters[i], canAddCollectionsToCache);
 					}
 				}
 			}
 		}
 
-		private static void EndCollectionLoad(object resultSetId, ISessionImplementor session, ICollectionPersister collectionPersister)
+        private static void EndCollectionLoad(object resultSetId, ISessionImplementor session, ICollectionPersister collectionPersister, bool canAddCollectionsToCache)
 		{
 			//this is a query and we are loading multiple instances of the same collection role
 			session.PersistenceContext.LoadContexts.GetCollectionLoadContext((DbDataReader)resultSetId).EndLoadingCollections(
-				collectionPersister);
+				collectionPersister, canAddCollectionsToCache);
 		}
 
 		

Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,8 @@ public IPersistentCollection GetLoadingCollection(ICollectionPersister persister`
`144`	`144`	`/// complete.`
`145`	`145`	`/// </summary>`
`146`	`146`	`/// <param name="persister">The persister for which to complete loading. </param>`
`147`		`- public void EndLoadingCollections(ICollectionPersister persister)`
	`147`	`+ /// <param name="canAddCollectionsToCache">Indicates if collcetion can be put in cache</param>`
	`148`	`+ public void EndLoadingCollections(ICollectionPersister persister, bool canAddCollectionsToCache)`
`148`	`149`	`{`
`149`	`150`	`if (!loadContexts.HasLoadingCollectionEntries && (localLoadingCollectionKeys.Count == 0))`
`150`	`151`	`{`
`@@ -189,7 +190,7 @@ public void EndLoadingCollections(ICollectionPersister persister)`
`189`	`190`	`}`
`190`	`191`	`localLoadingCollectionKeys.ExceptWith(toRemove);`
`191`	`192`
`192`		`- EndLoadingCollections(persister, matches);`
	`193`	`+ EndLoadingCollections(persister, matches, canAddCollectionsToCache);`
`193`	`194`	`if ((localLoadingCollectionKeys.Count == 0))`
`194`	`195`	`{`
`195`	`196`	`// todo : hack!!!`
`@@ -202,7 +203,7 @@ public void EndLoadingCollections(ICollectionPersister persister)`
`202`	`203`	`}`
`203`	`204`	`}`
`204`	`205`
`205`		`- private void EndLoadingCollections(ICollectionPersister persister, IList<LoadingCollectionEntry> matchedCollectionEntries)`
	`206`	`+ private void EndLoadingCollections(ICollectionPersister persister, IList<LoadingCollectionEntry> matchedCollectionEntries, bool canAddCollectionsToCache)`
`206`	`207`	`{`
`207`	`208`	`if (matchedCollectionEntries == null \|\| matchedCollectionEntries.Count == 0)`
`208`	`209`	`{`
`@@ -221,7 +222,7 @@ private void EndLoadingCollections(ICollectionPersister persister, IList<Loading`
`221`	`222`
`222`	`223`	`for (int i = 0; i < count; i++)`
`223`	`224`	`{`
`224`		`- EndLoadingCollection(matchedCollectionEntries[i], persister);`
	`225`	`+ EndLoadingCollection(matchedCollectionEntries[i], persister, canAddCollectionsToCache);`
`225`	`226`	`}`
`226`	`227`
`227`	`228`	`if (log.IsDebugEnabled())`
`@@ -230,7 +231,7 @@ private void EndLoadingCollections(ICollectionPersister persister, IList<Loading`
`230`	`231`	`}`
`231`	`232`	`}`
`232`	`233`
`233`		`- private void EndLoadingCollection(LoadingCollectionEntry lce, ICollectionPersister persister)`
	`234`	`+ private void EndLoadingCollection(LoadingCollectionEntry lce, ICollectionPersister persister, bool canAddCollectionsToCache)`
`234`	`235`	`{`
`235`	`236`	`if (log.IsDebugEnabled())`
`236`	`237`	`{`
`@@ -264,7 +265,7 @@ private void EndLoadingCollection(LoadingCollectionEntry lce, ICollectionPersist`
`264`	`265`	`ce.PostInitialize(lce.Collection, persistenceContext);`
`265`	`266`	`}`
`266`	`267`
`267`		`- bool addToCache = hasNoQueuedAdds && persister.HasCache &&`
	`268`	`+ bool addToCache = canAddCollectionsToCache && hasNoQueuedAdds && persister.HasCache &&`
`268`	`269`	`session.CacheMode.HasFlag(CacheMode.Put) && !ce.IsDoremove; // and this is not a forced initialization during flush`
`269`	`270`
`270`	`271`	`if (addToCache)`
Original file line number	Diff line number	Diff line change
`@@ -687,6 +687,7 @@ public sealed partial class Subcriteria : ICriteria, ISupportSelectModeCriteria`
`687`	`687`	`private LockMode lockMode;`
`688`	`688`	`private readonly JoinType joinType;`
`689`	`689`	`private ICriterion withClause;`
	`690`	`+ private bool hasRestrictions;`
`690`	`691`
`691`	`692`	`internal Subcriteria(CriteriaImpl root, ICriteria parent, string path, string alias, JoinType joinType, ICriterion withClause, string joinEntityName = null)`
`692`	`693`	`{`
`@@ -697,6 +698,7 @@ internal Subcriteria(CriteriaImpl root, ICriteria parent, string path, string al`
`697`	`698`	`this.joinType = joinType;`
`698`	`699`	`this.withClause = withClause;`
`699`	`700`	`JoinEntityName = joinEntityName;`
	`701`	`+ hasRestrictions = withClause != null;`
`700`	`702`
`701`	`703`	`root.subcriteriaList.Add(this);`
`702`	`704`
`@@ -730,6 +732,11 @@ public string Path`
`730`	`732`	`get { return path; }`
`731`	`733`	`}`
`732`	`734`
	`735`	`+ public bool HasRestrictions`
	`736`	`+ {`
	`737`	`+ get { return hasRestrictions; }`
	`738`	`+ }`
	`739`	`+`
`733`	`740`	`public ICriteria Parent`
`734`	`741`	`{`
`735`	`742`	`get { return parent; }`
`@@ -769,6 +776,7 @@ public ICriteria SetLockMode(LockMode lockMode)`
`769`	`776`
`770`	`777`	`public ICriteria Add(ICriterion expression)`
`771`	`778`	`{`
	`779`	`+ hasRestrictions = true;`
`772`	`780`	`root.Add(this, expression);`
`773`	`781`	`return this;`
`774`	`782`	`}`
Original file line number	Diff line number	Diff line change
`@@ -267,7 +267,7 @@ private void GetResultsFromDatabase(IList results)`
`267`	`267`	`for (int i = 0; i < loaders.Count; i++)`
`268`	`268`	`{`
`269`	`269`	`CriteriaLoader loader = loaders[i];`
`270`		`- loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, session.DefaultReadOnly);`
	`270`	`+ loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, session.DefaultReadOnly, parameters[i].CanAddCollectionsToCache);`
`271`	`271`
`272`	`272`	`if (createSubselects[i])`
`273`	`273`	`{`
Original file line number	Diff line number	Diff line change
`@@ -606,7 +606,7 @@ protected List<object> DoList()`
`606`	`606`	`ITranslator translator = translators[i];`
`607`	`607`	`QueryParameters parameter = parameters[i];`
`608`	`608`
`609`		`- translator.Loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, false);`
	`609`	`+ translator.Loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, false, parameters[i].CanAddCollectionsToCache);`
`610`	`610`
`611`	`611`	`if (createSubselects[i])`
`612`	`612`	`{`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ protected override bool IsChildFetchEntity(int i)`
`94`	`94`
`95`	`95`	`public IList List(ISessionImplementor session)`
`96`	`96`	`{`
`97`		`- return List(session, translator.GetQueryParameters(), querySpaces);`
	`97`	`+ return List(session, translator.GetQueryParameters(), querySpaces);`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`protected override IResultTransformer ResolveResultTransformer(IResultTransformer resultTransformer)`
Original file line number	Diff line number	Diff line change
`@@ -139,6 +139,7 @@ public QueryParameters GetQueryParameters()`
`139`	`139`	`selection.FetchSize = rootCriteria.FetchSize;`
`140`	`140`
`141`	`141`	`var lockModes = new Dictionary<string, LockMode>();`
	`142`	`+ var canAddCollectionsToCache = true;`
`142`	`143`	`foreach (KeyValuePair<string, LockMode> me in rootCriteria.LockModes)`
`143`	`144`	`{`
`144`	`145`	`ICriteria subcriteria = GetAliasedCriteria(me.Key);`
`@@ -152,6 +153,9 @@ public QueryParameters GetQueryParameters()`
`152`	`153`	`{`
`153`	`154`	`lockModes[GetSQLAlias(subcriteria)] = lm;`
`154`	`155`	`}`
	`156`	`+`
	`157`	`+ if (subcriteria.HasRestrictions && subcriteria.JoinType == JoinType.LeftOuterJoin)`
	`158`	`+ canAddCollectionsToCache = false;`
`155`	`159`	`}`
`156`	`160`
`157`	`161`	`IDictionary<string, TypedValue> queryNamedParameters = CollectedParameters.ToDictionary(np => np.Name, np => new TypedValue(np.Type, np.Value));`
`@@ -167,7 +171,8 @@ public QueryParameters GetQueryParameters()`
`167`	`171`	`rootCriteria.CacheRegion,`
`168`	`172`	`rootCriteria.Comment,`
`169`	`173`	`rootCriteria.LookupByNaturalKey,`
`170`		`- rootCriteria.ResultTransformer);`
	`174`	`+ rootCriteria.ResultTransformer,`
	`175`	`+ canAddCollectionsToCache);`
`171`	`176`	`}`
`172`	`177`
`173`	`178`	`public SqlString GetGroupBy()`
Original file line number	Diff line number	Diff line change
`@@ -310,7 +310,7 @@ protected object LoadSingleRow(DbDataReader resultSet, ISessionImplementor sessi`
`310`	`310`	`queryParameters.NamedParameters);`
`311`	`311`	`}`
`312`	`312`
`313`		`- InitializeEntitiesAndCollections(hydratedObjects, resultSet, session, queryParameters.IsReadOnly(session));`
	`313`	`+ InitializeEntitiesAndCollections(hydratedObjects, resultSet, session, queryParameters.IsReadOnly(session), queryParameters.CanAddCollectionsToCache);`
`314`	`314`	`session.PersistenceContext.InitializeNonLazyCollections();`
`315`	`315`	`return result;`
`316`	`316`	`}`
`@@ -512,7 +512,7 @@ private IList DoQuery(ISessionImplementor session, QueryParameters queryParamete`
`512`	`512`	`session.Batcher.CloseCommand(st, rs);`
`513`	`513`	`}`
`514`	`514`
`515`		`- InitializeEntitiesAndCollections(hydratedObjects, rs, session, queryParameters.IsReadOnly(session));`
	`515`	`+ InitializeEntitiesAndCollections(hydratedObjects, rs, session, queryParameters.IsReadOnly(session), queryParameters.CanAddCollectionsToCache);`
`516`	`516`
`517`	`517`	`if (createSubselects)`
`518`	`518`	`{`
`@@ -594,7 +594,7 @@ private IEnumerable<SubselectFetch> CreateSubselects(IList<EntityKey[]> keys, Qu`
`594`	`594`	`}`
`595`	`595`	`}`
`596`	`596`
`597`		`- internal void InitializeEntitiesAndCollections(IList hydratedObjects, object resultSetId, ISessionImplementor session, bool readOnly)`
	`597`	`+ internal void InitializeEntitiesAndCollections(IList hydratedObjects, object resultSetId, ISessionImplementor session, bool readOnly, bool canAddCollectionsToCache)`
`598`	`598`	`{`
`599`	`599`	`ICollectionPersister[] collectionPersisters = CollectionPersisters;`
`600`	`600`	`if (collectionPersisters != null)`
`@@ -608,7 +608,7 @@ internal void InitializeEntitiesAndCollections(IList hydratedObjects, object res`
`608`	`608`	`//during loading`
`609`	`609`	`//TODO: or we could do this polymorphically, and have two`
`610`	`610`	`// different operations implemented differently for arrays`
`611`		`- EndCollectionLoad(resultSetId, session, collectionPersisters[i]);`
	`611`	`+ EndCollectionLoad(resultSetId, session, collectionPersisters[i], canAddCollectionsToCache);`
`612`	`612`	`}`
`613`	`613`	`}`
`614`	`614`	`}`
`@@ -652,17 +652,17 @@ internal void InitializeEntitiesAndCollections(IList hydratedObjects, object res`
`652`	`652`	`//the entities, since we might call hashCode() on the elements`
`653`	`653`	`//TODO: or we could do this polymorphically, and have two`
`654`	`654`	`// different operations implemented differently for arrays`
`655`		`- EndCollectionLoad(resultSetId, session, collectionPersisters[i]);`
	`655`	`+ EndCollectionLoad(resultSetId, session, collectionPersisters[i], canAddCollectionsToCache);`
`656`	`656`	`}`
`657`	`657`	`}`
`658`	`658`	`}`
`659`	`659`	`}`
`660`	`660`
`661`		`- private static void EndCollectionLoad(object resultSetId, ISessionImplementor session, ICollectionPersister collectionPersister)`
	`661`	`+ private static void EndCollectionLoad(object resultSetId, ISessionImplementor session, ICollectionPersister collectionPersister, bool canAddCollectionsToCache)`
`662`	`662`	`{`
`663`	`663`	`//this is a query and we are loading multiple instances of the same collection role`
`664`	`664`	`session.PersistenceContext.LoadContexts.GetCollectionLoadContext((DbDataReader)resultSetId).EndLoadingCollections(`
`665`		`- collectionPersister);`
	`665`	`+ collectionPersister, canAddCollectionsToCache);`
`666`	`666`	`}`
`667`	`667`
`668`	`668`