Skip to content

Commit 97f283d

Browse files
fredericDelaportefredericDelaporte
committed
Merge branch '5.3.x'
# Conflicts: # build-common/NHibernate.props
2 parents 47992e7 + 19ddf5c commit 97f283d

20 files changed

+624
-37
lines changed

‎releasenotes.txt

+19-1
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,22 @@
1-
Build 5.3.6
1+
Build 5.3.7
2+
=============================
3+
4+
Release notes - NHibernate - Version 5.3.7
5+
6+
5 issues were resolved in this release.
7+
8+
** Bug
9+
10+
* #2704 IEnhancedUserType from string to bool fails in some circumstances
11+
* #2702 LINQ projection of nullable enum with list fails
12+
* #2693 Invalid parameter conversion with group by
13+
* #2688 NoViableAltException in a delete on a many-to-one id
14+
15+
** Task
16+
17+
* #2701 Release 5.3.7
18+
19+
Build 5.3.6
220
=============================
321

422
Release notes - NHibernate - Version 5.3.6

‎src/NHibernate.Test/Async/Hql/EntityJoinHqlTest.cs

+17
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@
88
//------------------------------------------------------------------------------
99

1010

11+
using System;
1112
using System.Text.RegularExpressions;
1213
using NHibernate.Cfg.MappingSchema;
1314
using NHibernate.Mapping.ByCode;
@@ -233,6 +234,21 @@ public async Task NullablePropRefWhereIdEntityNotNullShouldAddJoinAsync()
233234
}
234235
}
235236

237+
[Test(Description = "GH-2688")]
238+
public async Task NullableManyToOneDeleteQueryAsync()
239+
{
240+
using (var session = OpenSession())
241+
{
242+
await (session
243+
.CreateQuery(
244+
"delete "
245+
+ "from NullableOwner ex "
246+
+ "where ex.ManyToOne.id = :id"
247+
).SetParameter("id", Guid.Empty)
248+
.ExecuteUpdateAsync());
249+
}
250+
}
251+
236252
[Test]
237253
public async Task NullableOneToOneFetchQueryIsNotAffectedAsync()
238254
{
@@ -539,6 +555,7 @@ protected override HbmMapping GetMappings()
539555
m.ForeignKey("none");
540556
m.NotFound(NotFoundMode.Ignore);
541557
});
558+
rc.ManyToOne(e => e.ManyToOne, m => m.NotFound(NotFoundMode.Ignore));
542559
});
543560

544561

‎src/NHibernate.Test/Async/Linq/ByMethod/GroupByHavingTests.cs

+41
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@
1010

1111
using System;
1212
using System.Linq;
13+
using NHibernate.DomainModel.Northwind.Entities;
1314
using NUnit.Framework;
1415
using NHibernate.Linq;
1516

@@ -147,5 +148,45 @@ public async Task SingleKeyGroupAndCountWithHavingClauseAsync()
147148
var hornRow = orderCounts.Single(row => row.CompanyName == "Around the Horn");
148149
Assert.That(hornRow.OrderCount, Is.EqualTo(13));
149150
}
151+
152+
[Test]
153+
public async Task HavingWithStringEnumParameterAsync()
154+
{
155+
await (db.Users
156+
.GroupBy(p => p.Enum1)
157+
.Where(g => g.Key == EnumStoredAsString.Large)
158+
.Select(g => g.Count())
159+
.ToListAsync());
160+
await (db.Users
161+
.GroupBy(p => new StringEnumGroup {Enum = p.Enum1})
162+
.Where(g => g.Key.Enum == EnumStoredAsString.Large)
163+
.Select(g => g.Count())
164+
.ToListAsync());
165+
await (db.Users
166+
.GroupBy(p => new[] {p.Enum1})
167+
.Where(g => g.Key[0] == EnumStoredAsString.Large)
168+
.Select(g => g.Count())
169+
.ToListAsync());
170+
await (db.Users
171+
.GroupBy(p => new {p.Enum1})
172+
.Where(g => g.Key.Enum1 == EnumStoredAsString.Large)
173+
.Select(g => g.Count())
174+
.ToListAsync());
175+
await (db.Users
176+
.GroupBy(p => new {Test = new {Test2 = p.Enum1}})
177+
.Where(g => g.Key.Test.Test2 == EnumStoredAsString.Large)
178+
.Select(g => g.Count())
179+
.ToListAsync());
180+
await (db.Users
181+
.GroupBy(p => new {Test = new[] {p.Enum1}})
182+
.Where(g => g.Key.Test[0] == EnumStoredAsString.Large)
183+
.Select(g => g.Count())
184+
.ToListAsync());
185+
}
186+
187+
private class StringEnumGroup
188+
{
189+
public EnumStoredAsString Enum { get; set; }
190+
}
150191
}
151192
}

‎src/NHibernate.Test/Async/Linq/ByMethod/GroupByTests.cs

+34
Original file line numberDiff line numberDiff line change
@@ -382,6 +382,40 @@ public async Task GroupByAndAnyAsync()
382382
Assert.That(namesAreNotEmpty, Is.True);
383383
}
384384

385+
[Test]
386+
public async Task GroupByWithStringEnumParameterAsync()
387+
{
388+
await (db.Users
389+
.GroupBy(p => p.Enum1)
390+
.Select(g => g.Key == EnumStoredAsString.Large ? g.Sum(o => o.Id) : 0)
391+
.ToListAsync());
392+
await (db.Users
393+
.GroupBy(p => new StringEnumGroup {Enum = p.Enum1})
394+
.Select(g => g.Key.Enum == EnumStoredAsString.Large ? g.Sum(o => o.Id) : 0)
395+
.ToListAsync());
396+
await (db.Users
397+
.GroupBy(p => new[] {p.Enum1})
398+
.Select(g => g.Key[0] == EnumStoredAsString.Large ? g.Sum(o => o.Id) : 0)
399+
.ToListAsync());
400+
await (db.Users
401+
.GroupBy(p => new {p.Enum1})
402+
.Select(g => g.Key.Enum1 == EnumStoredAsString.Large ? g.Sum(o => o.Id) : 0)
403+
.ToListAsync());
404+
await (db.Users
405+
.GroupBy(p => new {Test = new {Test2 = p.Enum1}})
406+
.Select(g => g.Key.Test.Test2 == EnumStoredAsString.Large ? g.Sum(o => o.Id) : 0)
407+
.ToListAsync());
408+
await (db.Users
409+
.GroupBy(p => new {Test = new[] {p.Enum1}})
410+
.Select(g => g.Key.Test[0] == EnumStoredAsString.Large ? g.Sum(o => o.Id) : 0)
411+
.ToListAsync());
412+
}
413+
414+
private class StringEnumGroup
415+
{
416+
public EnumStoredAsString Enum { get; set; }
417+
}
418+
385419
[Test]
386420
public async Task SelectFirstElementFromProductsGroupedByUnitPriceAsync()
387421
{

‎src/NHibernate.Test/Async/Linq/EnumTests.cs

+36
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@
99

1010

1111
using System;
12+
using System.Collections.Generic;
1213
using System.Linq;
1314
using NHibernate.Cfg.MappingSchema;
1415
using NHibernate.Mapping.ByCode;
@@ -50,9 +51,24 @@ protected override HbmMapping GetMappings()
5051
m.Type(_enumType);
5152
m.Formula($"(case when Enum1 = {_unspecifiedValue} then null else Enum1 end)");
5253
});
54+
rc.Bag(x => x.Children, m =>
55+
{
56+
m.Cascade(Mapping.ByCode.Cascade.All);
57+
m.Inverse(true);
58+
},
59+
a => a.OneToMany()
60+
);
5361
rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All));
5462
});
5563

64+
mapper.Class<EnumEntityChild>(
65+
rc =>
66+
{
67+
rc.Table("EnumEntityChild");
68+
rc.Id(x => x.Id, m => m.Generator(Generators.Guid));
69+
rc.Property(x => x.Name);
70+
});
71+
5672
return mapper.CompileMappingForAllExplicitlyAddedEntities();
5773
}
5874

@@ -184,5 +200,25 @@ public async Task CanQueryComplexExpressionOnTestEnumAsync()
184200
Assert.That(query.Count, Is.EqualTo(0));
185201
}
186202
}
203+
204+
[Test]
205+
public async Task CanProjectWithListTransformationAsync()
206+
{
207+
using (var session = OpenSession())
208+
using (var trans = session.BeginTransaction())
209+
{
210+
var entities = session.Query<EnumEntity>();
211+
212+
var query = await (entities.Select(user => new
213+
{
214+
user.Name,
215+
simple = user.Enum1,
216+
children = user.Children,
217+
nullableEnum1IsLarge = user.NullableEnum1 == TestEnum.Large
218+
}).ToListAsync());
219+
220+
Assert.That(query.Count, Is.EqualTo(10));
221+
}
222+
}
187223
}
188224
}

‎src/NHibernate.Test/Async/NHSpecificTest/GH2704/FixtureByCode.cs

+82
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,82 @@
1+
//------------------------------------------------------------------------------
2+
// <auto-generated>
3+
// This code was generated by AsyncGenerator.
4+
//
5+
// Changes to this file may cause incorrect behavior and will be lost if
6+
// the code is regenerated.
7+
// </auto-generated>
8+
//------------------------------------------------------------------------------
9+
10+
11+
using System.Linq;
12+
using NHibernate.Cfg.MappingSchema;
13+
using NHibernate.Mapping.ByCode;
14+
using NUnit.Framework;
15+
using NHibernate.Linq;
16+
17+
namespace NHibernate.Test.NHSpecificTest.GH2704
18+
{
19+
using System.Threading.Tasks;
20+
[TestFixture]
21+
public class EnhancedUserTypeFixtureAsync : TestCaseMappingByCode
22+
{
23+
protected override HbmMapping GetMappings()
24+
{
25+
var mapper = new ModelMapper();
26+
27+
mapper.AddMapping<Entity1Map>();
28+
return mapper.CompileMappingForAllExplicitlyAddedEntities();
29+
}
30+
31+
protected override void OnSetUp()
32+
{
33+
using (var session = OpenSession())
34+
using (var transaction = session.BeginTransaction())
35+
{
36+
session.Save(new Entity1() {Id = "id1", IsChiusa = true});
37+
session.Save(new Entity1() {Id = "id2", IsChiusa = false});
38+
transaction.Commit();
39+
}
40+
}
41+
42+
protected override void OnTearDown()
43+
{
44+
using (var session = OpenSession())
45+
using (var transaction = session.BeginTransaction())
46+
{
47+
session.CreateQuery("delete from System.Object").ExecuteUpdate();
48+
transaction.Commit();
49+
}
50+
}
51+
52+
[Test]
53+
public async Task CompareWithConstantAsync()
54+
{
55+
var yes = true;
56+
using (var s = OpenSession())
57+
Assert.IsTrue(await (s.Query<Entity1>().Where(x => x.IsChiusa == yes).AnyAsync()));
58+
}
59+
60+
[Test]
61+
public async Task NotOnPropertyAsync()
62+
{
63+
using (var s = OpenSession())
64+
Assert.IsTrue(await (s.Query<Entity1>().Where(x => !x.IsChiusa).AllAsync(x => !x.IsChiusa)));
65+
}
66+
67+
[Test]
68+
public async Task CompareWithInlineConstantAsync()
69+
{
70+
using (var s = OpenSession())
71+
Assert.IsTrue(await (s.Query<Entity1>().Where(x => x.IsChiusa == false).AnyAsync()));
72+
}
73+
74+
[Test]
75+
public async Task CompareWithNotOnConstantAsync()
76+
{
77+
var no = false;
78+
using (var s = OpenSession())
79+
Assert.IsTrue(await (s.Query<Entity1>().Where(x => x.IsChiusa == !no).AnyAsync()));
80+
}
81+
}
82+
}

‎src/NHibernate.Test/Hql/EntityJoinHqlTest.cs

+18-1
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
1-
using System.Text.RegularExpressions;
1+
using System;
2+
using System.Text.RegularExpressions;
23
using NHibernate.Cfg.MappingSchema;
34
using NHibernate.Mapping.ByCode;
45
using NHibernate.Test.Hql.EntityJoinHqlTestEntities;
@@ -222,6 +223,21 @@ public void NullablePropRefWhereIdEntityNotNullShouldAddJoin()
222223
}
223224
}
224225

226+
[Test(Description = "GH-2688")]
227+
public void NullableManyToOneDeleteQuery()
228+
{
229+
using (var session = OpenSession())
230+
{
231+
session
232+
.CreateQuery(
233+
"delete "
234+
+ "from NullableOwner ex "
235+
+ "where ex.ManyToOne.id = :id"
236+
).SetParameter("id", Guid.Empty)
237+
.ExecuteUpdate();
238+
}
239+
}
240+
225241
[Test]
226242
public void NullableOneToOneFetchQueryIsNotAffected()
227243
{
@@ -544,6 +560,7 @@ protected override HbmMapping GetMappings()
544560
m.ForeignKey("none");
545561
m.NotFound(NotFoundMode.Ignore);
546562
});
563+
rc.ManyToOne(e => e.ManyToOne, m => m.NotFound(NotFoundMode.Ignore));
547564
});
548565

549566

‎src/NHibernate.Test/Hql/EntityJoinHqlTestEntities.cs

+1
Original file line numberDiff line numberDiff line change
@@ -31,6 +31,7 @@ public class NullableOwner
3131
public virtual string Name { get; set; }
3232
public virtual OneToOneEntity OneToOne { get; set; }
3333
public virtual PropRefEntity PropRef { get; set; }
34+
public virtual OneToOneEntity ManyToOne { get; set; }
3435
}
3536

3637
public class EntityWithCompositeId

‎src/NHibernate.Test/Linq/ByMethod/GroupByHavingTests.cs

+41
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
using System;
22
using System.Linq;
3+
using NHibernate.DomainModel.Northwind.Entities;
34
using NUnit.Framework;
45

56
namespace NHibernate.Test.Linq.ByMethod
@@ -135,5 +136,45 @@ public void SingleKeyGroupAndCountWithHavingClause()
135136
var hornRow = orderCounts.Single(row => row.CompanyName == "Around the Horn");
136137
Assert.That(hornRow.OrderCount, Is.EqualTo(13));
137138
}
139+
140+
[Test]
141+
public void HavingWithStringEnumParameter()
142+
{
143+
db.Users
144+
.GroupBy(p => p.Enum1)
145+
.Where(g => g.Key == EnumStoredAsString.Large)
146+
.Select(g => g.Count())
147+
.ToList();
148+
db.Users
149+
.GroupBy(p => new StringEnumGroup {Enum = p.Enum1})
150+
.Where(g => g.Key.Enum == EnumStoredAsString.Large)
151+
.Select(g => g.Count())
152+
.ToList();
153+
db.Users
154+
.GroupBy(p => new[] {p.Enum1})
155+
.Where(g => g.Key[0] == EnumStoredAsString.Large)
156+
.Select(g => g.Count())
157+
.ToList();
158+
db.Users
159+
.GroupBy(p => new {p.Enum1})
160+
.Where(g => g.Key.Enum1 == EnumStoredAsString.Large)
161+
.Select(g => g.Count())
162+
.ToList();
163+
db.Users
164+
.GroupBy(p => new {Test = new {Test2 = p.Enum1}})
165+
.Where(g => g.Key.Test.Test2 == EnumStoredAsString.Large)
166+
.Select(g => g.Count())
167+
.ToList();
168+
db.Users
169+
.GroupBy(p => new {Test = new[] {p.Enum1}})
170+
.Where(g => g.Key.Test[0] == EnumStoredAsString.Large)
171+
.Select(g => g.Count())
172+
.ToList();
173+
}
174+
175+
private class StringEnumGroup
176+
{
177+
public EnumStoredAsString Enum { get; set; }
178+
}
138179
}
139180
}

0 commit comments

Comments
 (0)