Fix using Criteria and QuerOver for NH-3848

itmagination · fredericDelaporte · commit d0fe800c5a1d · 2018-11-16T13:04:51.000+01:00
diff --git a/src/NHibernate.Test/NHSpecificTest/NH3848/CriteriaTestFixture.cs b/src/NHibernate.Test/NHSpecificTest/NH3848/CriteriaTestFixture.cs
@@ -18,7 +18,7 @@ protected override IList<Customer> GetCustomersWithFetchedOrdersWithoutRestricti
         protected override IList<Customer> GetCustomersWithOrdersEagerLoaded(ISession session)
         {
             return session.CreateCriteria<Customer>()
-                          .SetFetchMode("Orders", FetchMode.Eager)
+                          .Fetch(SelectMode.Fetch, "Orders")
                           .SetResultTransformer(new DistinctRootEntityResultTransformer())
                           .List<Customer>();
         }
diff --git a/src/NHibernate.Test/NHSpecificTest/NH3848/QueryOverTestFixture.cs b/src/NHibernate.Test/NHSpecificTest/NH3848/QueryOverTestFixture.cs
@@ -21,7 +21,7 @@ protected override IList<Customer> GetCustomersWithFetchedOrdersWithoutRestricti
         protected override IList<Customer> GetCustomersWithOrdersEagerLoaded(ISession session)
         {
             return session.QueryOver<Customer>()
-                                .Fetch(n => n.Orders).Eager
+                                .Fetch(SelectMode.Fetch, n => n.Orders)
                                 .TransformUsing(new DistinctRootEntityResultTransformer())
                                 .List();
         }
diff --git a/src/NHibernate.Test/NHSpecificTest/NH3848/TestFixture.cs b/src/NHibernate.Test/NHSpecificTest/NH3848/TestFixture.cs
@@ -235,13 +235,12 @@ public void ChildCollectionsFromLeftOuterJoinShouldBeInSecondLevelCacheIfQueryCo
         protected void ClearSecondLevelCacheFor(System.Type entity)
         {
             var entityName = entity.FullName;
-            sessions.EvictEntity(entityName);
-            var entityPersister = sessions.GetEntityPersister(entityName);
+            Sfi.EvictEntity(entityName);
+            var entityPersister = Sfi.GetEntityPersister(entityName);
             if (!entityPersister.HasCache)
                 return;
 
-            var querySpaces = entityPersister.QuerySpaces.Cast<object>().ToArray();
-            sessions.UpdateTimestampsCache.Invalidate(querySpaces);
+            Sfi.UpdateTimestampsCache.PreInvalidate(entityPersister.QuerySpaces.ToList());
         }
 
         protected void ClearCollectionCache<T>(Expression<Func<T, IEnumerable>> pathToCollection)
@@ -252,7 +251,7 @@ protected void ClearCollectionCache<T>(Expression<Func<T, IEnumerable>> pathToCo
                 throw new ArgumentException("pathToCollection should be member expression");
 
             var role = string.Format("{0}.{1}", rootEntityTypeFullPath, memberExpression.Member.Name);
-            sessions.EvictCollection(role);
+            Sfi.EvictCollection(role);
         }
 
         protected abstract IList<Customer> GetCustomersWithFetchedOrdersWithoutRestrictions(ISession session);
diff --git a/src/NHibernate/Engine/Loading/CollectionLoadContext.cs b/src/NHibernate/Engine/Loading/CollectionLoadContext.cs
@@ -145,7 +145,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))
 			{
@@ -190,7 +191,7 @@ public void EndLoadingCollections(ICollectionPersister persister)
 			}
 			localLoadingCollectionKeys.ExceptWith(toRemove);
 
-			EndLoadingCollections(persister, matches);
+            EndLoadingCollections(persister, matches, canAddCollectionsToCache);
 			if ((localLoadingCollectionKeys.Count == 0))
 			{
 				// todo : hack!!!
@@ -203,7 +204,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)
 			{
@@ -224,7 +225,7 @@ private void EndLoadingCollections(ICollectionPersister persister, IList<Loading
 			for (int i = 0; i < count; i++)
 			{
 				EndLoadingCollection(matchedCollectionEntries[i], persister,
-				                     data => cacheBatcher.AddToBatch(persister, data));
+				                     data => cacheBatcher.AddToBatch(persister, data), canAddCollectionsToCache);
 			}
 			cacheBatcher.ExecuteBatch();
 
@@ -235,7 +236,7 @@ private void EndLoadingCollections(ICollectionPersister persister, IList<Loading
 		}
 
 		private void EndLoadingCollection(LoadingCollectionEntry lce, ICollectionPersister persister,
-		                                  Action<CachePutData> cacheBatchingHandler)
+		                                  Action<CachePutData> cacheBatchingHandler, bool canAddCollectionsToCache)
 		{
 			if (log.IsDebugEnabled())
 			{
@@ -269,7 +270,7 @@ private void EndLoadingCollection(LoadingCollectionEntry lce, ICollectionPersist
 				ce.PostInitialize(lce.Collection, persistenceContext);
 			}
 
-			bool addToCache = hasNoQueuedOperations && persister.HasCache && 
+			bool addToCache = canAddCollectionsToCache && hasNoQueuedOperations && 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
@@ -37,28 +37,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>();
@@ -72,14 +72,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;
@@ -139,6 +140,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
@@ -688,6 +688,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)
 			{
@@ -698,6 +699,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);
 
@@ -731,6 +733,11 @@ public string Path
 				get { return path; }
 			}
 
+		    public bool HasRestrictions
+		    {
+		        get { return hasRestrictions; }
+		    }
+
 			public ICriteria Parent
 			{
 				get { return parent; }
@@ -770,6 +777,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
@@ -273,7 +273,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, null, parameters[i].CanAddCollectionsToCache);
 
 						if (createSubselects[i])
 						{
diff --git a/src/NHibernate/Impl/MultiQueryImpl.cs b/src/NHibernate/Impl/MultiQueryImpl.cs
@@ -616,7 +616,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, null, 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)
 				{
 					CacheMode = rootCriteria.CacheMode
 				};
diff --git a/src/NHibernate/Loader/Loader.cs b/src/NHibernate/Loader/Loader.cs
@@ -315,7 +315,7 @@ protected object LoadSingleRow(DbDataReader resultSet, ISessionImplementor sessi
 												 queryParameters.NamedParameters);
 			}
 
-			InitializeEntitiesAndCollections(hydratedObjects, resultSet, session, queryParameters.IsReadOnly(session));
+            InitializeEntitiesAndCollections(hydratedObjects, resultSet, session, queryParameters.IsReadOnly(session), null, queryParameters.CanAddCollectionsToCache);
 			session.PersistenceContext.InitializeNonLazyCollections();
 			return result;
 		}
@@ -517,7 +517,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), null, queryParameters.CanAddCollectionsToCache);
 
 				if (createSubselects)
 				{
@@ -601,7 +601,7 @@ private IEnumerable<SubselectFetch> CreateSubselects(IList<EntityKey[]> keys, Qu
 
 		internal void InitializeEntitiesAndCollections(
 			IList hydratedObjects, object resultSetId, ISessionImplementor session, bool readOnly,
-			CacheBatcher cacheBatcher = null)
+			CacheBatcher cacheBatcher = null, bool canAddCollectionsToCache = true)
 		{
 			ICollectionPersister[] collectionPersisters = CollectionPersisters;
 			if (collectionPersisters != null)
@@ -615,7 +615,7 @@ internal void InitializeEntitiesAndCollections(
 						//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);
 					}
 				}
 			}
@@ -666,17 +666,17 @@ internal void InitializeEntitiesAndCollections(
 						//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
`@@ -18,7 +18,7 @@ protected override IList<Customer> GetCustomersWithFetchedOrdersWithoutRestricti`
`18`	`18`	`protected override IList<Customer> GetCustomersWithOrdersEagerLoaded(ISession session)`
`19`	`19`	`{`
`20`	`20`	`return session.CreateCriteria<Customer>()`
`21`		`- .SetFetchMode("Orders", FetchMode.Eager)`
	`21`	`+ .Fetch(SelectMode.Fetch, "Orders")`
`22`	`22`	`.SetResultTransformer(new DistinctRootEntityResultTransformer())`
`23`	`23`	`.List<Customer>();`
`24`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ protected override IList<Customer> GetCustomersWithFetchedOrdersWithoutRestricti`
`21`	`21`	`protected override IList<Customer> GetCustomersWithOrdersEagerLoaded(ISession session)`
`22`	`22`	`{`
`23`	`23`	`return session.QueryOver<Customer>()`
`24`		`- .Fetch(n => n.Orders).Eager`
	`24`	`+ .Fetch(SelectMode.Fetch, n => n.Orders)`
`25`	`25`	`.TransformUsing(new DistinctRootEntityResultTransformer())`
`26`	`26`	`.List();`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,8 @@ public IPersistentCollection GetLoadingCollection(ICollectionPersister persister`
`145`	`145`	`/// complete.`
`146`	`146`	`/// </summary>`
`147`	`147`	`/// <param name="persister">The persister for which to complete loading. </param>`
`148`		`- public void EndLoadingCollections(ICollectionPersister persister)`
	`148`	`+ /// <param name="canAddCollectionsToCache">Indicates if collcetion can be put in cache</param>`
	`149`	`+ public void EndLoadingCollections(ICollectionPersister persister, bool canAddCollectionsToCache)`
`149`	`150`	`{`
`150`	`151`	`if (!loadContexts.HasLoadingCollectionEntries && (localLoadingCollectionKeys.Count == 0))`
`151`	`152`	`{`
`@@ -190,7 +191,7 @@ public void EndLoadingCollections(ICollectionPersister persister)`
`190`	`191`	`}`
`191`	`192`	`localLoadingCollectionKeys.ExceptWith(toRemove);`
`192`	`193`
`193`		`- EndLoadingCollections(persister, matches);`
	`194`	`+ EndLoadingCollections(persister, matches, canAddCollectionsToCache);`
`194`	`195`	`if ((localLoadingCollectionKeys.Count == 0))`
`195`	`196`	`{`
`196`	`197`	`// todo : hack!!!`
`@@ -203,7 +204,7 @@ public void EndLoadingCollections(ICollectionPersister persister)`
`203`	`204`	`}`
`204`	`205`	`}`
`205`	`206`
`206`		`- private void EndLoadingCollections(ICollectionPersister persister, IList<LoadingCollectionEntry> matchedCollectionEntries)`
	`207`	`+ private void EndLoadingCollections(ICollectionPersister persister, IList<LoadingCollectionEntry> matchedCollectionEntries, bool canAddCollectionsToCache)`
`207`	`208`	`{`
`208`	`209`	`if (matchedCollectionEntries == null \|\| matchedCollectionEntries.Count == 0)`
`209`	`210`	`{`
`@@ -224,7 +225,7 @@ private void EndLoadingCollections(ICollectionPersister persister, IList<Loading`
`224`	`225`	`for (int i = 0; i < count; i++)`
`225`	`226`	`{`
`226`	`227`	`EndLoadingCollection(matchedCollectionEntries[i], persister,`
`227`		`- data => cacheBatcher.AddToBatch(persister, data));`
	`228`	`+ data => cacheBatcher.AddToBatch(persister, data), canAddCollectionsToCache);`
`228`	`229`	`}`
`229`	`230`	`cacheBatcher.ExecuteBatch();`
`230`	`231`
`@@ -235,7 +236,7 @@ private void EndLoadingCollections(ICollectionPersister persister, IList<Loading`
`235`	`236`	`}`
`236`	`237`
`237`	`238`	`private void EndLoadingCollection(LoadingCollectionEntry lce, ICollectionPersister persister,`
`238`		`- Action<CachePutData> cacheBatchingHandler)`
	`239`	`+ Action<CachePutData> cacheBatchingHandler, bool canAddCollectionsToCache)`
`239`	`240`	`{`
`240`	`241`	`if (log.IsDebugEnabled())`
`241`	`242`	`{`
`@@ -269,7 +270,7 @@ private void EndLoadingCollection(LoadingCollectionEntry lce, ICollectionPersist`
`269`	`270`	`ce.PostInitialize(lce.Collection, persistenceContext);`
`270`	`271`	`}`
`271`	`272`
`272`		`- bool addToCache = hasNoQueuedOperations && persister.HasCache &&`
	`273`	`+ bool addToCache = canAddCollectionsToCache && hasNoQueuedOperations && persister.HasCache &&`
`273`	`274`	`session.CacheMode.HasFlag(CacheMode.Put) && !ce.IsDoremove; // and this is not a forced initialization during flush`
`274`	`275`
`275`	`276`	`if (addToCache)`
Original file line number	Diff line number	Diff line change
`@@ -688,6 +688,7 @@ public sealed partial class Subcriteria : ICriteria, ISupportSelectModeCriteria`
`688`	`688`	`private LockMode lockMode;`
`689`	`689`	`private readonly JoinType joinType;`
`690`	`690`	`private ICriterion withClause;`
	`691`	`+ private bool hasRestrictions;`
`691`	`692`
`692`	`693`	`internal Subcriteria(CriteriaImpl root, ICriteria parent, string path, string alias, JoinType joinType, ICriterion withClause, string joinEntityName = null)`
`693`	`694`	`{`
`@@ -698,6 +699,7 @@ internal Subcriteria(CriteriaImpl root, ICriteria parent, string path, string al`
`698`	`699`	`this.joinType = joinType;`
`699`	`700`	`this.withClause = withClause;`
`700`	`701`	`JoinEntityName = joinEntityName;`
	`702`	`+ hasRestrictions = withClause != null;`
`701`	`703`
`702`	`704`	`root.subcriteriaList.Add(this);`
`703`	`705`
`@@ -731,6 +733,11 @@ public string Path`
`731`	`733`	`get { return path; }`
`732`	`734`	`}`
`733`	`735`
	`736`	`+ public bool HasRestrictions`
	`737`	`+ {`
	`738`	`+ get { return hasRestrictions; }`
	`739`	`+ }`
	`740`	`+`
`734`	`741`	`public ICriteria Parent`
`735`	`742`	`{`
`736`	`743`	`get { return parent; }`
`@@ -770,6 +777,7 @@ public ICriteria SetLockMode(LockMode lockMode)`
`770`	`777`
`771`	`778`	`public ICriteria Add(ICriterion expression)`
`772`	`779`	`{`
	`780`	`+ hasRestrictions = true;`
`773`	`781`	`root.Add(this, expression);`
`774`	`782`	`return this;`
`775`	`783`	`}`
Original file line number	Diff line number	Diff line change
`@@ -273,7 +273,7 @@ private void GetResultsFromDatabase(IList results)`
`273`	`273`	`for (int i = 0; i < loaders.Count; i++)`
`274`	`274`	`{`
`275`	`275`	`CriteriaLoader loader = loaders[i];`
`276`		`- loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, session.DefaultReadOnly);`
	`276`	`+ loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, session.DefaultReadOnly, null, parameters[i].CanAddCollectionsToCache);`
`277`	`277`
`278`	`278`	`if (createSubselects[i])`
`279`	`279`	`{`
Original file line number	Diff line number	Diff line change
`@@ -616,7 +616,7 @@ protected List<object> DoList()`
`616`	`616`	`ITranslator translator = translators[i];`
`617`	`617`	`QueryParameters parameter = parameters[i];`
`618`	`618`
`619`		`- translator.Loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, false);`
	`619`	`+ translator.Loader.InitializeEntitiesAndCollections(hydratedObjects[i], reader, session, false, null, parameters[i].CanAddCollectionsToCache);`
`620`	`620`
`621`	`621`	`if (createSubselects[i])`
`622`	`622`	`{`
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`	`CacheMode = rootCriteria.CacheMode`
`173`	`178`	`};`
Original file line number	Diff line number	Diff line change
`@@ -315,7 +315,7 @@ protected object LoadSingleRow(DbDataReader resultSet, ISessionImplementor sessi`
`315`	`315`	`queryParameters.NamedParameters);`
`316`	`316`	`}`
`317`	`317`
`318`		`- InitializeEntitiesAndCollections(hydratedObjects, resultSet, session, queryParameters.IsReadOnly(session));`
	`318`	`+ InitializeEntitiesAndCollections(hydratedObjects, resultSet, session, queryParameters.IsReadOnly(session), null, queryParameters.CanAddCollectionsToCache);`
`319`	`319`	`session.PersistenceContext.InitializeNonLazyCollections();`
`320`	`320`	`return result;`
`321`	`321`	`}`
`@@ -517,7 +517,7 @@ private IList DoQuery(ISessionImplementor session, QueryParameters queryParamete`
`517`	`517`	`session.Batcher.CloseCommand(st, rs);`
`518`	`518`	`}`
`519`	`519`
`520`		`- InitializeEntitiesAndCollections(hydratedObjects, rs, session, queryParameters.IsReadOnly(session));`
	`520`	`+ InitializeEntitiesAndCollections(hydratedObjects, rs, session, queryParameters.IsReadOnly(session), null, queryParameters.CanAddCollectionsToCache);`
`521`	`521`
`522`	`522`	`if (createSubselects)`
`523`	`523`	`{`
`@@ -601,7 +601,7 @@ private IEnumerable<SubselectFetch> CreateSubselects(IList<EntityKey[]> keys, Qu`
`601`	`601`
`602`	`602`	`internal void InitializeEntitiesAndCollections(`
`603`	`603`	`IList hydratedObjects, object resultSetId, ISessionImplementor session, bool readOnly,`
`604`		`- CacheBatcher cacheBatcher = null)`
	`604`	`+ CacheBatcher cacheBatcher = null, bool canAddCollectionsToCache = true)`
`605`	`605`	`{`
`606`	`606`	`ICollectionPersister[] collectionPersisters = CollectionPersisters;`
`607`	`607`	`if (collectionPersisters != null)`
`@@ -615,7 +615,7 @@ internal void InitializeEntitiesAndCollections(`
`615`	`615`	`//during loading`
`616`	`616`	`//TODO: or we could do this polymorphically, and have two`
`617`	`617`	`// different operations implemented differently for arrays`
`618`		`- EndCollectionLoad(resultSetId, session, collectionPersisters[i]);`
	`618`	`+ EndCollectionLoad(resultSetId, session, collectionPersisters[i], canAddCollectionsToCache);`
`619`	`619`	`}`
`620`	`620`	`}`
`621`	`621`	`}`
`@@ -666,17 +666,17 @@ internal void InitializeEntitiesAndCollections(`
`666`	`666`	`//the entities, since we might call hashCode() on the elements`
`667`	`667`	`//TODO: or we could do this polymorphically, and have two`
`668`	`668`	`// different operations implemented differently for arrays`
`669`		`- EndCollectionLoad(resultSetId, session, collectionPersisters[i]);`
	`669`	`+ EndCollectionLoad(resultSetId, session, collectionPersisters[i], canAddCollectionsToCache);`
`670`	`670`	`}`
`671`	`671`	`}`
`672`	`672`	`}`
`673`	`673`	`}`
`674`	`674`
`675`		`- private static void EndCollectionLoad(object resultSetId, ISessionImplementor session, ICollectionPersister collectionPersister)`
	`675`	`+ private static void EndCollectionLoad(object resultSetId, ISessionImplementor session, ICollectionPersister collectionPersister, bool canAddCollectionsToCache)`
`676`	`676`	`{`
`677`	`677`	`//this is a query and we are loading multiple instances of the same collection role`
`678`	`678`	`session.PersistenceContext.LoadContexts.GetCollectionLoadContext((DbDataReader)resultSetId).EndLoadingCollections(`
`679`		`- collectionPersister);`
	`679`	`+ collectionPersister, canAddCollectionsToCache);`
`680`	`680`	`}`
`681`	`681`
`682`	`682`