Skip to content

Commit 1102acf

Browse files
fredericDelaportefredericDelaporte
committed
Resolve collection owner correctly in case of property-ref
Root cause of NH-3480
1 parent 0245389 commit 1102acf

19 files changed

+353
-59
lines changed

‎src/NHibernate.Test/Async/NHSpecificTest/NH3480/Fixture.cs

+25-1
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,15 @@ protected override void OnSetUp()
2626
{
2727
using (ITransaction transaction = session.BeginTransaction())
2828
{
29-
var parent1 = new Entity { Id = new Entity.Key() { Id = Guid.NewGuid() }, Name = "Bob", OtherId = 20 };
29+
var parent1 = new Entity
30+
{
31+
Id = new Entity.Key { Id = Guid.NewGuid() },
32+
Name = "Bob",
33+
OtherId = 20,
34+
YetAnotherOtherId = 21
35+
};
36+
parent1.Elements.Add(1);
37+
parent1.Elements.Add(2);
3038
session.Save(parent1);
3139

3240
var child1 = new Child { Name = "Bob1", Parent = parent1 };
@@ -72,5 +80,21 @@ public async Task TestAsync()
7280
}
7381
}
7482
}
83+
84+
[Test]
85+
public async Task TestOwnerAsync()
86+
{
87+
using (var session = OpenSession())
88+
using (var t = session.BeginTransaction())
89+
{
90+
var entity = await (session.Query<Entity>().SingleAsync(e => e.Name == "Bob"));
91+
92+
// The Elements collection is mapped with a custom type which assert the owner
93+
// is not null.
94+
await (NHibernateUtil.InitializeAsync(entity.Elements));
95+
Assert.That(entity.Elements, Has.Count.GreaterThan(0));
96+
await (t.CommitAsync());
97+
}
98+
}
7599
}
76100
}

‎src/NHibernate.Test/NHSpecificTest/NH3480/Entity.cs

+81-1
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,10 @@
11
using System;
22
using System.Collections.Generic;
3+
using System.Data.Common;
4+
using NHibernate.Engine;
5+
using NHibernate.SqlTypes;
6+
using NHibernate.UserTypes;
7+
using NUnit.Framework;
38

49
namespace NHibernate.Test.NHSpecificTest.NH3480
510
{
@@ -13,7 +18,9 @@ public Entity()
1318
public virtual Key Id { get; set; }
1419
public virtual string Name { get; set; }
1520
public virtual int OtherId { get; set; }
21+
public virtual int YetAnotherOtherId { get; set; }
1622
public virtual ISet<Child> Children { get; set; }
23+
public virtual ISet<int> Elements { get; set; } = new HashSet<int>();
1724

1825
public override bool Equals(object obj)
1926
{
@@ -58,4 +65,77 @@ class Child
5865
public virtual string Name { get; set; }
5966
public virtual Entity Parent { get; set; }
6067
}
61-
}
68+
69+
// This user type is the Elements collection element type
70+
public class SimpleCustomType : IUserType
71+
{
72+
private static readonly SqlType[] ReturnSqlTypes = { SqlTypeFactory.Int32 };
73+
74+
#region IUserType Members
75+
76+
public new bool Equals(object x, object y)
77+
{
78+
if (ReferenceEquals(x, y))
79+
{
80+
return true;
81+
}
82+
if (x == null || y == null)
83+
{
84+
return false;
85+
}
86+
87+
return x.Equals(y);
88+
}
89+
90+
public int GetHashCode(object x)
91+
{
92+
return x?.GetHashCode() ?? 0;
93+
}
94+
95+
public SqlType[] SqlTypes => ReturnSqlTypes;
96+
97+
public object DeepCopy(object value)
98+
{
99+
return value;
100+
}
101+
102+
public void NullSafeSet(DbCommand cmd, object value, int index, ISessionImplementor session)
103+
{
104+
cmd.Parameters[index].Value = value ?? DBNull.Value;
105+
}
106+
107+
public System.Type ReturnedType => typeof(int);
108+
109+
public object NullSafeGet(DbDataReader rs, string[] names, ISessionImplementor session, object owner)
110+
{
111+
// Detect if the root cause of the bug is still there: if yes, the owner will be null.
112+
Assert.That(owner, Is.Not.Null);
113+
114+
var index = rs.GetOrdinal(names[0]);
115+
if (rs.IsDBNull(index))
116+
{
117+
return null;
118+
}
119+
return rs.GetInt32(index);
120+
}
121+
122+
public bool IsMutable => false;
123+
124+
public object Replace(object original, object target, object owner)
125+
{
126+
return original;
127+
}
128+
129+
public object Assemble(object cached, object owner)
130+
{
131+
return cached;
132+
}
133+
134+
public object Disassemble(object value)
135+
{
136+
return value;
137+
}
138+
139+
#endregion
140+
}
141+
}

‎src/NHibernate.Test/NHSpecificTest/NH3480/Fixture.cs

+25-1
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,15 @@ protected override void OnSetUp()
1515
{
1616
using (ITransaction transaction = session.BeginTransaction())
1717
{
18-
var parent1 = new Entity { Id = new Entity.Key() { Id = Guid.NewGuid() }, Name = "Bob", OtherId = 20 };
18+
var parent1 = new Entity
19+
{
20+
Id = new Entity.Key { Id = Guid.NewGuid() },
21+
Name = "Bob",
22+
OtherId = 20,
23+
YetAnotherOtherId = 21
24+
};
25+
parent1.Elements.Add(1);
26+
parent1.Elements.Add(2);
1927
session.Save(parent1);
2028

2129
var child1 = new Child { Name = "Bob1", Parent = parent1 };
@@ -61,5 +69,21 @@ public void Test()
6169
}
6270
}
6371
}
72+
73+
[Test]
74+
public void TestOwner()
75+
{
76+
using (var session = OpenSession())
77+
using (var t = session.BeginTransaction())
78+
{
79+
var entity = session.Query<Entity>().Single(e => e.Name == "Bob");
80+
81+
// The Elements collection is mapped with a custom type which assert the owner
82+
// is not null.
83+
NHibernateUtil.Initialize(entity.Elements);
84+
Assert.That(entity.Elements, Has.Count.GreaterThan(0));
85+
t.Commit();
86+
}
87+
}
6488
}
6589
}

‎src/NHibernate.Test/NHSpecificTest/NH3480/Mappings.hbm.xml

+8-3
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,21 @@
11
<?xml version="1.0" encoding="utf-8" ?>
22
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="NHibernate.Test" namespace="NHibernate.Test.NHSpecificTest.NH3480">
33

4-
<class name="Entity">
4+
<class name="Entity">
55
<composite-id name="Id">
66
<key-property name="Id" />
77
</composite-id>
8-
<property name="Name" not-null="true" />
8+
<property name="Name" not-null="true" />
99
<property name="OtherId" unique="true" not-null="true" />
10+
<property name="YetAnotherOtherId" unique="true" not-null="true" />
1011
<set name="Children" cascade="all-delete-orphan" inverse="true">
1112
<key property-ref="OtherId" column="Parent" />
1213
<one-to-many class="Child" />
1314
</set>
15+
<set name="Elements">
16+
<key property-ref="YetAnotherOtherId" column="Parent" />
17+
<element type="NHibernate.Test.NHSpecificTest.NH3480.SimpleCustomType, NHibernate.Test"/>
18+
</set>
1419
</class>
1520

1621
<class name="Child">
@@ -19,4 +24,4 @@
1924
<many-to-one name="Parent" property-ref="OtherId" not-null="true" />
2025
</class>
2126

22-
</hibernate-mapping>
27+
</hibernate-mapping>

‎src/NHibernate/Async/Engine/BatchFetchQueue.cs

+4-4
Original file line numberDiff line numberDiff line change
@@ -47,18 +47,18 @@ public Task<object[]> GetCollectionBatchAsync(ICollectionPersister collectionPer
4747
/// Get a batch of uninitialized collection keys for a given role
4848
/// </summary>
4949
/// <param name="collectionPersister">The persister for the collection role.</param>
50-
/// <param name="id">A key that must be included in the batch fetch</param>
50+
/// <param name="key">A key that must be included in the batch fetch</param>
5151
/// <param name="batchSize">the maximum number of keys to return</param>
5252
/// <param name="checkCache">Whether to check the cache for uninitialized collection keys.</param>
5353
/// <param name="collectionEntries">An array that will be filled with collection entries if set.</param>
5454
/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
5555
/// <returns>An array of collection keys, of length <paramref name="batchSize"/> (padded with nulls)</returns>
56-
internal async Task<object[]> GetCollectionBatchAsync(ICollectionPersister collectionPersister, object id, int batchSize, bool checkCache,
56+
internal async Task<object[]> GetCollectionBatchAsync(ICollectionPersister collectionPersister, object key, int batchSize, bool checkCache,
5757
CollectionEntry[] collectionEntries, CancellationToken cancellationToken)
5858
{
5959
cancellationToken.ThrowIfCancellationRequested();
6060
var keys = new object[batchSize];
61-
keys[0] = id; // The first element of array is reserved for the actual instance we are loading
61+
keys[0] = key; // The first element of array is reserved for the actual instance we are loading
6262
var i = 1; // The current index of keys array
6363
int? keyIndex = null; // The index of the demanding key in the linked hash set
6464
var checkForEnd = false; // Stores whether we found the demanded collection and reached the batchSize
@@ -159,7 +159,7 @@ async Task<bool> ProcessKeyAsync(KeyValuePair<CollectionEntry, IPersistentCollec
159159
{
160160
return true;
161161
}
162-
if (collectionPersister.KeyType.IsEqual(id, ce.LoadedKey, collectionPersister.Factory))
162+
if (collectionPersister.KeyType.IsEqual(key, ce.LoadedKey, collectionPersister.Factory))
163163
{
164164
if (collectionEntries != null)
165165
{

‎src/NHibernate/Async/Event/Default/DefaultInitializeCollectionEventListener.cs

+11-9
Original file line numberDiff line numberDiff line change
@@ -73,10 +73,11 @@ public virtual async Task OnInitializeCollectionAsync(InitializeCollectionEvent
7373
}
7474

7575
/// <summary> Try to initialize a collection from the cache</summary>
76-
private async Task<bool> InitializeCollectionFromCacheAsync(object id, ICollectionPersister persister, IPersistentCollection collection, ISessionImplementor source, CancellationToken cancellationToken)
76+
private async Task<bool> InitializeCollectionFromCacheAsync(
77+
object collectionKey, ICollectionPersister persister, IPersistentCollection collection,
78+
ISessionImplementor source, CancellationToken cancellationToken)
7779
{
7880
cancellationToken.ThrowIfCancellationRequested();
79-
8081
if (!(source.EnabledFilters.Count == 0) && persister.IsAffectedByEnabledFilters(source))
8182
{
8283
log.Debug("disregarding cached version (if any) of collection due to enabled filters ");
@@ -96,7 +97,7 @@ private async Task<bool> InitializeCollectionFromCacheAsync(object id, ICollecti
9697
var collectionEntries = new CollectionEntry[batchSize];
9798
// The first item in the array is the item that we want to load
9899
var collectionBatch = await (source.PersistenceContext.BatchFetchQueue
99-
.GetCollectionBatchAsync(persister, id, batchSize, false, collectionEntries, cancellationToken)).ConfigureAwait(false);
100+
.GetCollectionBatchAsync(persister, collectionKey, batchSize, false, collectionEntries, cancellationToken)).ConfigureAwait(false);
100101
// Ignore null values as the retrieved batch may contains them when there are not enough
101102
// uninitialized collection in the queue
102103
var keys = new List<CacheKey>(batchSize);
@@ -115,16 +116,17 @@ private async Task<bool> InitializeCollectionFromCacheAsync(object id, ICollecti
115116
var coll = source.PersistenceContext.BatchFetchQueue.GetBatchLoadableCollection(persister, collectionEntries[i]);
116117
await (AssembleAsync(keys[i], cachedObjects[i], persister, source, coll, collectionBatch[i], false, cancellationToken)).ConfigureAwait(false);
117118
}
118-
return await (AssembleAsync(keys[0], cachedObjects[0], persister, source, collection, id, true, cancellationToken)).ConfigureAwait(false);
119+
return await (AssembleAsync(keys[0], cachedObjects[0], persister, source, collection, collectionKey, true, cancellationToken)).ConfigureAwait(false);
119120
}
120121

121-
var cacheKey = source.GenerateCacheKey(id, persister.KeyType, persister.Role);
122+
var cacheKey = source.GenerateCacheKey(collectionKey, persister.KeyType, persister.Role);
122123
var cachedObject = await (persister.Cache.GetAsync(cacheKey, source.Timestamp, cancellationToken)).ConfigureAwait(false);
123-
return await (AssembleAsync(cacheKey, cachedObject, persister, source, collection, id, true, cancellationToken)).ConfigureAwait(false);
124+
return await (AssembleAsync(cacheKey, cachedObject, persister, source, collection, collectionKey, true, cancellationToken)).ConfigureAwait(false);
124125
}
125126

126-
private async Task<bool> AssembleAsync(CacheKey ck, object ce, ICollectionPersister persister, ISessionImplementor source,
127-
IPersistentCollection collection, object id, bool alterStatistics, CancellationToken cancellationToken)
127+
private async Task<bool> AssembleAsync(
128+
CacheKey ck, object ce, ICollectionPersister persister, ISessionImplementor source,
129+
IPersistentCollection collection, object collectionKey, bool alterStatistics, CancellationToken cancellationToken)
128130
{
129131
cancellationToken.ThrowIfCancellationRequested();
130132
ISessionFactoryImplementor factory = source.Factory;
@@ -158,7 +160,7 @@ private async Task<bool> AssembleAsync(CacheKey ck, object ce, ICollectionPersis
158160
IPersistenceContext persistenceContext = source.PersistenceContext;
159161

160162
CollectionCacheEntry cacheEntry = (CollectionCacheEntry) persister.CacheEntryStructure.Destructure(ce, factory);
161-
await (cacheEntry.AssembleAsync(collection, persister, persistenceContext.GetCollectionOwner(id, persister), cancellationToken)).ConfigureAwait(false);
163+
await (cacheEntry.AssembleAsync(collection, persister, persistenceContext.GetCollectionOwner(collectionKey, persister), cancellationToken)).ConfigureAwait(false);
162164

163165
persistenceContext.GetCollectionEntry(collection).PostInitialize(collection, persistenceContext);
164166

‎src/NHibernate/Async/Loader/Loader.cs

+39-2
Original file line numberDiff line numberDiff line change
@@ -646,9 +646,46 @@ private async Task<object[]> GetRowAsync(DbDataReader rs, ILoadable[] persisters
646646
obj =
647647
await (InstanceNotYetLoadedAsync(rs, i, persister, key, lockModes[i], optionalObjectKey,
648648
optionalObject, hydratedObjects, session, cancellationToken)).ConfigureAwait(false);
649+
650+
// IUniqueKeyLoadable.CacheByUniqueKeys caches all unique keys of the entity, regardless of
651+
// associations loaded by the query. So if the entity is already loaded, it has forcibly already
652+
// been cached too for all its unique keys, provided its persister implement it. With this new
653+
// way of caching unique keys, it is no more needed to handle caching for alreadyLoaded path
654+
// too.
655+
var cacheByUniqueKeysTask = (persister as IUniqueKeyLoadable)?.CacheByUniqueKeysAsync(obj, session, cancellationToken);
656+
657+
// IUniqueKeyLoadable.CacheByUniqueKeys caches all unique keys of the entity, regardless of
658+
// associations loaded by the query. So if the entity is already loaded, it has forcibly already
659+
// been cached too for all its unique keys, provided its persister implement it. With this new
660+
// way of caching unique keys, it is no more needed to handle caching for alreadyLoaded path
661+
// too.
662+
if (cacheByUniqueKeysTask != null)
663+
664+
// IUniqueKeyLoadable.CacheByUniqueKeys caches all unique keys of the entity, regardless of
665+
// associations loaded by the query. So if the entity is already loaded, it has forcibly already
666+
// been cached too for all its unique keys, provided its persister implement it. With this new
667+
// way of caching unique keys, it is no more needed to handle caching for alreadyLoaded path
668+
// too.
669+
{
670+
671+
// IUniqueKeyLoadable.CacheByUniqueKeys caches all unique keys of the entity, regardless of
672+
// associations loaded by the query. So if the entity is already loaded, it has forcibly already
673+
// been cached too for all its unique keys, provided its persister implement it. With this new
674+
// way of caching unique keys, it is no more needed to handle caching for alreadyLoaded path
675+
// too.
676+
await (cacheByUniqueKeysTask).ConfigureAwait(false);
677+
678+
// IUniqueKeyLoadable.CacheByUniqueKeys caches all unique keys of the entity, regardless of
679+
// associations loaded by the query. So if the entity is already loaded, it has forcibly already
680+
// been cached too for all its unique keys, provided its persister implement it. With this new
681+
// way of caching unique keys, it is no more needed to handle caching for alreadyLoaded path
682+
// too.
683+
}
649684
}
650-
// #1226: Even if it is already loaded, if it can be loaded from an association with a property ref, make
651-
// sure it is also cached by its unique key.
685+
// 6.0 TODO: this call is nor more needed for up-to-date persisters, remove once CacheByUniqueKeys
686+
// is merged in IUniqueKeyLoadable interface instead of being an extension method
687+
// #1226 old fix: Even if it is already loaded, if it can be loaded from an association with a property ref,
688+
// make sure it is also cached by its unique key.
652689
CacheByUniqueKey(i, persister, obj, session, alreadyLoaded);
653690
}
654691

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

+19
Original file line numberDiff line numberDiff line change
@@ -259,6 +259,25 @@ public Task<object> LoadByUniqueKeyAsync(string propertyName, object uniqueKey,
259259
}
260260
}
261261

262+
public async Task CacheByUniqueKeysAsync(object entity, ISessionImplementor session, CancellationToken cancellationToken)
263+
{
264+
cancellationToken.ThrowIfCancellationRequested();
265+
for (var i = 0; i < PropertySpan; i++)
266+
{
267+
if (!propertyUniqueness[i])
268+
continue;
269+
270+
// The caching is done by semi-resolved values.
271+
var propertyValue = session.PersistenceContext.GetEntry(entity).LoadedState[i];
272+
if (propertyValue == null)
273+
continue;
274+
var type = PropertyTypes[i].GetSemiResolvedType(session.Factory);
275+
propertyValue = await (type.SemiResolveAsync(propertyValue, session, entity, cancellationToken)).ConfigureAwait(false);
276+
var euk = new EntityUniqueKey(EntityName, PropertyNames[i], propertyValue, type, session.Factory);
277+
session.PersistenceContext.AddEntity(euk, entity);
278+
}
279+
}
280+
262281
protected Task<int> DehydrateAsync(object id, object[] fields, bool[] includeProperty, bool[][] includeColumns, int j, DbCommand st, ISessionImplementor session, CancellationToken cancellationToken)
263282
{
264283
if (cancellationToken.IsCancellationRequested)

0 commit comments

Comments
 (0)