From bc8424bb5422d8c39004a2aadda686f5e89e5d61 Mon Sep 17 00:00:00 2001 From: IllKostInf Date: Mon, 21 Sep 2020 12:57:07 +0300 Subject: [PATCH 1/5] Added unit test that checks caching query result set with ThenFetchMany statement --- .../NHSpecificTest/CachingComplexQuery/Car.cs | 12 ++ .../CachingComplexQuery/Child.cs | 20 +++ .../CachingComplexQuery/FixtureByCode.cs | 143 ++++++++++++++++++ .../CachingComplexQuery/Person.cs | 26 ++++ .../NHSpecificTest/CachingComplexQuery/Pet.cs | 12 ++ 5 files changed, 213 insertions(+) create mode 100644 src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Car.cs create mode 100644 src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Child.cs create mode 100644 src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/FixtureByCode.cs create mode 100644 src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Person.cs create mode 100644 src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Pet.cs diff --git a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Car.cs b/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Car.cs new file mode 100644 index 00000000000..6acde5dee57 --- /dev/null +++ b/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Car.cs @@ -0,0 +1,12 @@ +using System; + +namespace NHibernate.Test.NHSpecificTest.CachingComplexQuery +{ + public class Car + { + public virtual Guid Id { get; set; } + public virtual string Name { get; set; } + + public virtual Person Owner { get; set; } + } +} diff --git a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Child.cs b/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Child.cs new file mode 100644 index 00000000000..afd44003f2d --- /dev/null +++ b/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Child.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; + +namespace NHibernate.Test.NHSpecificTest.CachingComplexQuery +{ + public class Child + { + public virtual Guid Id { get; set; } + public virtual string Name { get; set; } + + public virtual Person Parent { get; set; } + + public virtual ISet Pets + { + get => _pets ?? (_pets = new HashSet()); + set => _pets = value; + } + private ISet _pets; + } +} diff --git a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/FixtureByCode.cs b/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/FixtureByCode.cs new file mode 100644 index 00000000000..869a6044b1f --- /dev/null +++ b/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/FixtureByCode.cs @@ -0,0 +1,143 @@ +using System.Linq; +using NHibernate.Cfg.MappingSchema; +using NHibernate.Mapping.ByCode; +using NHibernate.Linq; +using NUnit.Framework; + +namespace NHibernate.Test.NHSpecificTest.CachingComplexQuery +{ + /// + /// Fixture using 'by code' mappings + /// + /// + /// This fixture is identical to except the mapping is performed + /// by code in the GetMappings method, and does not require the Mappings.hbm.xml file. Use this approach + /// if you prefer. + /// + [TestFixture] + public class ByCodeFixture : TestCaseMappingByCode + { + protected override HbmMapping GetMappings() + { + var mapper = new ModelMapper(); + mapper.Class(rc => + { + rc.Id(x => x.Id, m => m.Generator(Generators.Guid)); + rc.Property(x => x.Name); + rc.Property(x => x.Age); + rc.Set( + x => x.Children, + colMap => + { + colMap.Inverse(true); + colMap.Cascade(Mapping.ByCode.Cascade.DeleteOrphans); + colMap.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }, + rel => rel.OneToMany()); + rc.Set( + x => x.Cars, + colMap => + { + colMap.Inverse(true); + colMap.Cascade(Mapping.ByCode.Cascade.DeleteOrphans); + colMap.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }, + rel => rel.OneToMany()); + rc.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }); + mapper.Class(ch => + { + ch.Id(x => x.Id, m => m.Generator(Generators.Guid)); + ch.Property(x => x.Name); + ch.ManyToOne(c => c.Parent); + + ch.Set( + x => x.Pets, + colMap => + { + colMap.Inverse(true); + colMap.Cascade(Mapping.ByCode.Cascade.DeleteOrphans); + colMap.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }, + rel => rel.OneToMany()); + + ch.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }); + mapper.Class(ch => + { + ch.Id(x => x.Id, m => m.Generator(Generators.Guid)); + ch.Property(x => x.Name); + ch.ManyToOne(c => c.Owner); + + ch.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }); + mapper.Class(ch => + { + ch.Id(x => x.Id, m => m.Generator(Generators.Guid)); + ch.Property(x => x.Name); + ch.ManyToOne(c => c.Owner); + + ch.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }); + + return mapper.CompileMappingForAllExplicitlyAddedEntities(); + } + + protected override void OnSetUp() + { + using (var session = OpenSession()) + using (var transaction = session.BeginTransaction()) + { + var person = new Person { Name = "Person 1", Age = 18 }; + + var car1 = new Car { Name = "Car1", Owner = person }; + var car2 = new Car { Name = "Car2", Owner = person }; + session.Save(car1); + session.Save(car2); + + session.Save(person); + transaction.Commit(); + } + } + + protected override void OnTearDown() + { + using (var session = OpenSession()) + using (var transaction = session.BeginTransaction()) + { + session.Delete("from Pet"); + session.Delete("from Child"); + session.Delete("from Car"); + session.Delete("from Person"); + + transaction.Commit(); + } + } + + [Test] + public void TestQueryCachingWithThenFetchMany() + { + using (var session = OpenSession()) + { + using (var transaction = session.BeginTransaction()) + { + var query = + session + .Query() + .FetchMany(p => p.Children) + .ThenFetchMany(ch => ch.Pets) + .FetchMany(p => p.Cars) as IQueryable; + + query = query.WithOptions(opt => + opt.SetCacheable(true) + .SetCacheMode(CacheMode.Normal) + .SetCacheRegion("Long_Cache")); + + query.ToList(); // First time the result will be cached + Assert.That(() => query.ToList(), Throws.Nothing); // + transaction.Commit(); + } + } + } + } +} diff --git a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Person.cs b/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Person.cs new file mode 100644 index 00000000000..f544f35fd55 --- /dev/null +++ b/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Person.cs @@ -0,0 +1,26 @@ +using System; +using System.Collections.Generic; + +namespace NHibernate.Test.NHSpecificTest.CachingComplexQuery +{ + public class Person + { + public virtual Guid Id { get; set; } + public virtual string Name { get; set; } + public virtual int Age { get; set; } + + public virtual ISet Cars + { + get => _cars ?? (_cars = new HashSet()); + set => _cars = value; + } + private ISet _cars; + + public virtual ISet Children + { + get => _children ?? (_children = new HashSet()); + set => _children = value; + } + private ISet _children; + } +} diff --git a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Pet.cs b/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Pet.cs new file mode 100644 index 00000000000..9795a26b66b --- /dev/null +++ b/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Pet.cs @@ -0,0 +1,12 @@ +using System; + +namespace NHibernate.Test.NHSpecificTest.CachingComplexQuery +{ + public class Pet + { + public virtual Guid Id { get; set; } + public virtual string Name { get; set; } + + public virtual Child Owner { get; set; } + } +} From 8d7a6e6071e2227e1cb10bf723c038cbf2b9349d Mon Sep 17 00:00:00 2001 From: IllKostInf Date: Tue, 22 Sep 2020 09:17:55 +0300 Subject: [PATCH 2/5] Cleaning --- .../CachingComplexQuery/FixtureByCode.cs | 49 +++++++------------ 1 file changed, 19 insertions(+), 30 deletions(-) diff --git a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/FixtureByCode.cs b/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/FixtureByCode.cs index 869a6044b1f..9e30e3b0e03 100644 --- a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/FixtureByCode.cs +++ b/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/FixtureByCode.cs @@ -6,14 +6,6 @@ namespace NHibernate.Test.NHSpecificTest.CachingComplexQuery { - /// - /// Fixture using 'by code' mappings - /// - /// - /// This fixture is identical to except the mapping is performed - /// by code in the GetMappings method, and does not require the Mappings.hbm.xml file. Use this approach - /// if you prefer. - /// [TestFixture] public class ByCodeFixture : TestCaseMappingByCode { @@ -94,7 +86,7 @@ protected override void OnSetUp() var car2 = new Car { Name = "Car2", Owner = person }; session.Save(car1); session.Save(car2); - + session.Save(person); transaction.Commit(); } @@ -105,11 +97,10 @@ protected override void OnTearDown() using (var session = OpenSession()) using (var transaction = session.BeginTransaction()) { - session.Delete("from Pet"); - session.Delete("from Child"); - session.Delete("from Car"); - session.Delete("from Person"); - + session.CreateQuery("delete from Pet").ExecuteUpdate(); + session.CreateQuery("delete from Child").ExecuteUpdate(); + session.CreateQuery("delete from Car").ExecuteUpdate(); + session.CreateQuery("delete from Person").ExecuteUpdate(); transaction.Commit(); } } @@ -118,25 +109,23 @@ protected override void OnTearDown() public void TestQueryCachingWithThenFetchMany() { using (var session = OpenSession()) + using (var transaction = session.BeginTransaction()) { - using (var transaction = session.BeginTransaction()) - { - var query = - session - .Query() - .FetchMany(p => p.Children) - .ThenFetchMany(ch => ch.Pets) - .FetchMany(p => p.Cars) as IQueryable; + var query = + session + .Query() + .FetchMany(p => p.Children) + .ThenFetchMany(ch => ch.Pets) + .FetchMany(p => p.Cars) as IQueryable; - query = query.WithOptions(opt => - opt.SetCacheable(true) - .SetCacheMode(CacheMode.Normal) - .SetCacheRegion("Long_Cache")); + query = query.WithOptions(opt => + opt.SetCacheable(true) + .SetCacheMode(CacheMode.Normal) + .SetCacheRegion("Long_Cache")); - query.ToList(); // First time the result will be cached - Assert.That(() => query.ToList(), Throws.Nothing); // - transaction.Commit(); - } + query.ToList(); // First time the result will be cached + Assert.That(() => query.ToList(), Throws.Nothing); + transaction.Commit(); } } } From 9e1f9302582d0f4dbf52ec9a9b46243ad44efd6b Mon Sep 17 00:00:00 2001 From: maca88 Date: Tue, 22 Sep 2020 13:17:59 +0200 Subject: [PATCH 3/5] Apply fix --- .../NHSpecificTest/GH2559/FixtureByCode.cs | 157 ++++++++++++++++++ .../{CachingComplexQuery => GH2559}/Car.cs | 2 +- .../{CachingComplexQuery => GH2559}/Child.cs | 2 +- .../FixtureByCode.cs | 24 ++- .../{CachingComplexQuery => GH2559}/Person.cs | 2 +- .../{CachingComplexQuery => GH2559}/Pet.cs | 2 +- src/NHibernate/Async/Type/CollectionType.cs | 2 +- src/NHibernate/Type/CollectionType.cs | 2 +- 8 files changed, 182 insertions(+), 11 deletions(-) create mode 100644 src/NHibernate.Test/Async/NHSpecificTest/GH2559/FixtureByCode.cs rename src/NHibernate.Test/NHSpecificTest/{CachingComplexQuery => GH2559}/Car.cs (73%) rename src/NHibernate.Test/NHSpecificTest/{CachingComplexQuery => GH2559}/Child.cs (85%) rename src/NHibernate.Test/NHSpecificTest/{CachingComplexQuery => GH2559}/FixtureByCode.cs (80%) rename src/NHibernate.Test/NHSpecificTest/{CachingComplexQuery => GH2559}/Person.cs (89%) rename src/NHibernate.Test/NHSpecificTest/{CachingComplexQuery => GH2559}/Pet.cs (73%) diff --git a/src/NHibernate.Test/Async/NHSpecificTest/GH2559/FixtureByCode.cs b/src/NHibernate.Test/Async/NHSpecificTest/GH2559/FixtureByCode.cs new file mode 100644 index 00000000000..6ee4685a810 --- /dev/null +++ b/src/NHibernate.Test/Async/NHSpecificTest/GH2559/FixtureByCode.cs @@ -0,0 +1,157 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by AsyncGenerator. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + + +using System.Linq; +using NHibernate.Cfg.MappingSchema; +using NHibernate.Linq; +using NHibernate.Mapping.ByCode; +using NUnit.Framework; + +namespace NHibernate.Test.NHSpecificTest.GH2559 +{ + using System.Threading.Tasks; + [TestFixture] + public class ByCodeFixtureAsync : TestCaseMappingByCode + { + protected override HbmMapping GetMappings() + { + var mapper = new ModelMapper(); + mapper.Class(rc => + { + rc.Id(x => x.Id, m => m.Generator(Generators.Guid)); + rc.Property(x => x.Name); + rc.Property(x => x.Age); + rc.Set( + x => x.Children, + colMap => + { + colMap.Inverse(true); + colMap.Cascade(Mapping.ByCode.Cascade.DeleteOrphans); + colMap.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }, + rel => rel.OneToMany()); + rc.Set( + x => x.Cars, + colMap => + { + colMap.Inverse(true); + colMap.Cascade(Mapping.ByCode.Cascade.DeleteOrphans); + colMap.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }, + rel => rel.OneToMany()); + rc.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }); + mapper.Class(ch => + { + ch.Id(x => x.Id, m => m.Generator(Generators.Guid)); + ch.Property(x => x.Name); + ch.ManyToOne(c => c.Parent); + + ch.Set( + x => x.Pets, + colMap => + { + colMap.Inverse(true); + colMap.Cascade(Mapping.ByCode.Cascade.DeleteOrphans); + colMap.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }, + rel => rel.OneToMany()); + + ch.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }); + mapper.Class(ch => + { + ch.Id(x => x.Id, m => m.Generator(Generators.Guid)); + ch.Property(x => x.Name); + ch.ManyToOne(c => c.Owner); + + ch.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }); + mapper.Class(ch => + { + ch.Id(x => x.Id, m => m.Generator(Generators.Guid)); + ch.Property(x => x.Name); + ch.ManyToOne(c => c.Owner); + + ch.Cache(c => c.Usage(CacheUsage.ReadWrite)); + }); + + return mapper.CompileMappingForAllExplicitlyAddedEntities(); + } + + protected override void OnSetUp() + { + using (var session = OpenSession()) + using (var transaction = session.BeginTransaction()) + { + var person = new Person { Name = "Person 1", Age = 18 }; + + var car1 = new Car { Name = "Car1", Owner = person }; + var car2 = new Car { Name = "Car2", Owner = person }; + session.Save(car1); + session.Save(car2); + + session.Save(person); + transaction.Commit(); + } + } + + protected override void OnTearDown() + { + using (var session = OpenSession()) + using (var transaction = session.BeginTransaction()) + { + session.CreateQuery("delete from Pet").ExecuteUpdate(); + session.CreateQuery("delete from Child").ExecuteUpdate(); + session.CreateQuery("delete from Car").ExecuteUpdate(); + session.CreateQuery("delete from Person").ExecuteUpdate(); + transaction.Commit(); + } + } + + [Test] + public async Task TestQueryCachingWithThenFetchManyAsync() + { + Person dbPerson; + Person cachePerson; + using (var session = OpenSession()) + using (var transaction = session.BeginTransaction()) + { + var query = + session + .Query() + .FetchMany(p => p.Children) + .ThenFetchMany(ch => ch.Pets) + .FetchMany(p => p.Cars) as IQueryable + ; + + query = query.WithOptions(opt => + opt.SetCacheable(true) + .SetCacheMode(CacheMode.Normal) + .SetCacheRegion("Long_Cache")); + + dbPerson = (await (query.ToListAsync())).First(); // First time the result will be cached + cachePerson = (await (query.ToListAsync())).First(); + + await (transaction.CommitAsync()); + } + + Assert.That(NHibernateUtil.IsInitialized(dbPerson.Cars), Is.True); + Assert.That(NHibernateUtil.IsInitialized(cachePerson.Cars), Is.True); + Assert.That(dbPerson.Cars, Has.Count.EqualTo(2)); + Assert.That(cachePerson.Cars, Has.Count.EqualTo(2)); + + Assert.That(NHibernateUtil.IsInitialized(dbPerson.Children), Is.True); + Assert.That(NHibernateUtil.IsInitialized(cachePerson.Children), Is.True); + Assert.That(dbPerson.Children, Has.Count.EqualTo(0)); + Assert.That(cachePerson.Children, Has.Count.EqualTo(0)); + } + } +} diff --git a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Car.cs b/src/NHibernate.Test/NHSpecificTest/GH2559/Car.cs similarity index 73% rename from src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Car.cs rename to src/NHibernate.Test/NHSpecificTest/GH2559/Car.cs index 6acde5dee57..b93e028c8b6 100644 --- a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Car.cs +++ b/src/NHibernate.Test/NHSpecificTest/GH2559/Car.cs @@ -1,6 +1,6 @@ using System; -namespace NHibernate.Test.NHSpecificTest.CachingComplexQuery +namespace NHibernate.Test.NHSpecificTest.GH2559 { public class Car { diff --git a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Child.cs b/src/NHibernate.Test/NHSpecificTest/GH2559/Child.cs similarity index 85% rename from src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Child.cs rename to src/NHibernate.Test/NHSpecificTest/GH2559/Child.cs index afd44003f2d..43f56d8b701 100644 --- a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Child.cs +++ b/src/NHibernate.Test/NHSpecificTest/GH2559/Child.cs @@ -1,7 +1,7 @@ using System; using System.Collections.Generic; -namespace NHibernate.Test.NHSpecificTest.CachingComplexQuery +namespace NHibernate.Test.NHSpecificTest.GH2559 { public class Child { diff --git a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/FixtureByCode.cs b/src/NHibernate.Test/NHSpecificTest/GH2559/FixtureByCode.cs similarity index 80% rename from src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/FixtureByCode.cs rename to src/NHibernate.Test/NHSpecificTest/GH2559/FixtureByCode.cs index 9e30e3b0e03..ec126a8f4a8 100644 --- a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/FixtureByCode.cs +++ b/src/NHibernate.Test/NHSpecificTest/GH2559/FixtureByCode.cs @@ -1,10 +1,10 @@ using System.Linq; using NHibernate.Cfg.MappingSchema; -using NHibernate.Mapping.ByCode; using NHibernate.Linq; +using NHibernate.Mapping.ByCode; using NUnit.Framework; -namespace NHibernate.Test.NHSpecificTest.CachingComplexQuery +namespace NHibernate.Test.NHSpecificTest.GH2559 { [TestFixture] public class ByCodeFixture : TestCaseMappingByCode @@ -108,6 +108,8 @@ protected override void OnTearDown() [Test] public void TestQueryCachingWithThenFetchMany() { + Person dbPerson; + Person cachePerson; using (var session = OpenSession()) using (var transaction = session.BeginTransaction()) { @@ -116,17 +118,29 @@ public void TestQueryCachingWithThenFetchMany() .Query() .FetchMany(p => p.Children) .ThenFetchMany(ch => ch.Pets) - .FetchMany(p => p.Cars) as IQueryable; + .FetchMany(p => p.Cars) as IQueryable + ; query = query.WithOptions(opt => opt.SetCacheable(true) .SetCacheMode(CacheMode.Normal) .SetCacheRegion("Long_Cache")); - query.ToList(); // First time the result will be cached - Assert.That(() => query.ToList(), Throws.Nothing); + dbPerson = query.ToList().First(); // First time the result will be cached + cachePerson = query.ToList().First(); + transaction.Commit(); } + + Assert.That(NHibernateUtil.IsInitialized(dbPerson.Cars), Is.True); + Assert.That(NHibernateUtil.IsInitialized(cachePerson.Cars), Is.True); + Assert.That(dbPerson.Cars, Has.Count.EqualTo(2)); + Assert.That(cachePerson.Cars, Has.Count.EqualTo(2)); + + Assert.That(NHibernateUtil.IsInitialized(dbPerson.Children), Is.True); + Assert.That(NHibernateUtil.IsInitialized(cachePerson.Children), Is.True); + Assert.That(dbPerson.Children, Has.Count.EqualTo(0)); + Assert.That(cachePerson.Children, Has.Count.EqualTo(0)); } } } diff --git a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Person.cs b/src/NHibernate.Test/NHSpecificTest/GH2559/Person.cs similarity index 89% rename from src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Person.cs rename to src/NHibernate.Test/NHSpecificTest/GH2559/Person.cs index f544f35fd55..8d125021ec9 100644 --- a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Person.cs +++ b/src/NHibernate.Test/NHSpecificTest/GH2559/Person.cs @@ -1,7 +1,7 @@ using System; using System.Collections.Generic; -namespace NHibernate.Test.NHSpecificTest.CachingComplexQuery +namespace NHibernate.Test.NHSpecificTest.GH2559 { public class Person { diff --git a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Pet.cs b/src/NHibernate.Test/NHSpecificTest/GH2559/Pet.cs similarity index 73% rename from src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Pet.cs rename to src/NHibernate.Test/NHSpecificTest/GH2559/Pet.cs index 9795a26b66b..7b580d24bd1 100644 --- a/src/NHibernate.Test/NHSpecificTest/CachingComplexQuery/Pet.cs +++ b/src/NHibernate.Test/NHSpecificTest/GH2559/Pet.cs @@ -1,6 +1,6 @@ using System; -namespace NHibernate.Test.NHSpecificTest.CachingComplexQuery +namespace NHibernate.Test.NHSpecificTest.GH2559 { public class Pet { diff --git a/src/NHibernate/Async/Type/CollectionType.cs b/src/NHibernate/Async/Type/CollectionType.cs index b103b445c22..a6a06de78d6 100644 --- a/src/NHibernate/Async/Type/CollectionType.cs +++ b/src/NHibernate/Async/Type/CollectionType.cs @@ -105,7 +105,7 @@ public override async Task BeforeAssembleAsync(object oid, ISessionImplementor s { cancellationToken.ThrowIfCancellationRequested(); var queryCacheQueue = session.PersistenceContext.BatchFetchQueue.QueryCacheQueue; - if (queryCacheQueue == null) + if (queryCacheQueue == null || oid == null) { return; } diff --git a/src/NHibernate/Type/CollectionType.cs b/src/NHibernate/Type/CollectionType.cs index 4ac7c434d53..7f4f4c05486 100644 --- a/src/NHibernate/Type/CollectionType.cs +++ b/src/NHibernate/Type/CollectionType.cs @@ -161,7 +161,7 @@ public override object Disassemble(object value, ISessionImplementor session, ob public override void BeforeAssemble(object oid, ISessionImplementor session) { var queryCacheQueue = session.PersistenceContext.BatchFetchQueue.QueryCacheQueue; - if (queryCacheQueue == null) + if (queryCacheQueue == null || oid == null) { return; } From e6662d6724693c01091262cd4bd1d93ad3534a2d Mon Sep 17 00:00:00 2001 From: maca88 Date: Tue, 22 Sep 2020 13:28:41 +0200 Subject: [PATCH 4/5] Fix spacing --- .../Async/NHSpecificTest/GH2559/FixtureByCode.cs | 3 +-- src/NHibernate.Test/NHSpecificTest/GH2559/FixtureByCode.cs | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/NHibernate.Test/Async/NHSpecificTest/GH2559/FixtureByCode.cs b/src/NHibernate.Test/Async/NHSpecificTest/GH2559/FixtureByCode.cs index 6ee4685a810..8dea23c6d76 100644 --- a/src/NHibernate.Test/Async/NHSpecificTest/GH2559/FixtureByCode.cs +++ b/src/NHibernate.Test/Async/NHSpecificTest/GH2559/FixtureByCode.cs @@ -129,8 +129,7 @@ public async Task TestQueryCachingWithThenFetchManyAsync() .Query() .FetchMany(p => p.Children) .ThenFetchMany(ch => ch.Pets) - .FetchMany(p => p.Cars) as IQueryable - ; + .FetchMany(p => p.Cars) as IQueryable; query = query.WithOptions(opt => opt.SetCacheable(true) diff --git a/src/NHibernate.Test/NHSpecificTest/GH2559/FixtureByCode.cs b/src/NHibernate.Test/NHSpecificTest/GH2559/FixtureByCode.cs index ec126a8f4a8..33348db8bd9 100644 --- a/src/NHibernate.Test/NHSpecificTest/GH2559/FixtureByCode.cs +++ b/src/NHibernate.Test/NHSpecificTest/GH2559/FixtureByCode.cs @@ -118,8 +118,7 @@ public void TestQueryCachingWithThenFetchMany() .Query() .FetchMany(p => p.Children) .ThenFetchMany(ch => ch.Pets) - .FetchMany(p => p.Cars) as IQueryable - ; + .FetchMany(p => p.Cars) as IQueryable; query = query.WithOptions(opt => opt.SetCacheable(true) From b75185326faa4f5e6e76aa1a2ae999924acf2de9 Mon Sep 17 00:00:00 2001 From: maca88 Date: Tue, 22 Sep 2020 23:32:59 +0200 Subject: [PATCH 5/5] Code review changes --- src/NHibernate/Async/Type/CollectionType.cs | 7 ++++++- src/NHibernate/Type/CollectionType.cs | 7 ++++++- 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/src/NHibernate/Async/Type/CollectionType.cs b/src/NHibernate/Async/Type/CollectionType.cs index a6a06de78d6..432c11957a8 100644 --- a/src/NHibernate/Async/Type/CollectionType.cs +++ b/src/NHibernate/Async/Type/CollectionType.cs @@ -104,8 +104,13 @@ public override async Task DisassembleAsync(object value, ISessionImplem public override async Task BeforeAssembleAsync(object oid, ISessionImplementor session, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); + if (oid == null) + { + return; + } + var queryCacheQueue = session.PersistenceContext.BatchFetchQueue.QueryCacheQueue; - if (queryCacheQueue == null || oid == null) + if (queryCacheQueue == null) { return; } diff --git a/src/NHibernate/Type/CollectionType.cs b/src/NHibernate/Type/CollectionType.cs index 7f4f4c05486..408e03d94ba 100644 --- a/src/NHibernate/Type/CollectionType.cs +++ b/src/NHibernate/Type/CollectionType.cs @@ -160,8 +160,13 @@ public override object Disassemble(object value, ISessionImplementor session, ob public override void BeforeAssemble(object oid, ISessionImplementor session) { + if (oid == null) + { + return; + } + var queryCacheQueue = session.PersistenceContext.BatchFetchQueue.QueryCacheQueue; - if (queryCacheQueue == null || oid == null) + if (queryCacheQueue == null) { return; }