Skip to content

Commit c2e5d9c

Browse files
hazzikhazzik
authored
Merge branch 'master' into GH-1180 
2 parents 6759a66 + 07aab2e commit c2e5d9c

File tree

70 files changed

+1737
-381
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

70 files changed

+1737
-381
lines changed

‎releasenotes.txt

Lines changed: 20 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,23 @@
1-
Build 5.3.1
1+
Build 5.3.2
2+
=============================
3+
4+
Release notes - NHibernate - Version 5.3.2
5+
6+
6 issues were resolved in this release.
7+
8+
** Bug
9+
10+
* #2468 Null reference at NHibernate.Util.AsyncReaderWriterLock.ReadLock()
11+
* #2465 Linq contains on a value collection is failing
12+
* #2463 Path expected for join
13+
* #2458 Evaluatable expressions with parameters are no more pre-evaluated
14+
* #2453 Fail to cast enum as nvarchar for Linq Contains
15+
16+
** Task
17+
18+
* #2472 Release 5.3.2
19+
20+
Build 5.3.1
221
=============================
322

423
Release notes - NHibernate - Version 5.3.1

‎src/NHibernate.Test/Async/Criteria/CriteriaQueryTest.cs

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2441,6 +2441,22 @@ public async Task SubcriteriaJoinTypesAsync()
24412441
session.Close();
24422442
}
24432443

2444+
public class NotMappedEntity
2445+
{
2446+
public virtual int Id { get; set; }
2447+
public virtual string Name { get; set; }
2448+
}
2449+
2450+
[Test]
2451+
public void CriteriaOnNotMappedEntityAsync()
2452+
{
2453+
using (ISession session = OpenSession())
2454+
{
2455+
Assert.ThrowsAsync<QueryException>(
2456+
() => session.CreateCriteria(typeof(NotMappedEntity)).ListAsync());
2457+
}
2458+
}
2459+
24442460
[Test]
24452461
public void TypeMismatchAsync()
24462462
{

‎src/NHibernate.Test/Async/Events/Collections/AbstractCollectionEventFixture.cs

Lines changed: 5 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@
88
//------------------------------------------------------------------------------
99

1010

11+
using System;
1112
using System.Collections;
1213
using System.Collections.Generic;
1314
using NHibernate.Collection;
@@ -38,30 +39,12 @@ protected override string MappingsAssembly
3839

3940
protected override void OnTearDown()
4041
{
41-
IParentWithCollection dummyParent = CreateParent("dummyParent");
42-
dummyParent.NewChildren(CreateCollection());
43-
IChild dummyChild = dummyParent.AddChild("dummyChild");
44-
45-
using (ISession s = OpenSession())
42+
using (var s = OpenSession())
43+
using (var tx = s.BeginTransaction())
4644
{
47-
using (ITransaction tx = s.BeginTransaction())
48-
{
49-
IList children = s.CreateCriteria(dummyChild.GetType()).List();
50-
IList parents = s.CreateCriteria(dummyParent.GetType()).List();
51-
foreach (IParentWithCollection parent in parents)
52-
{
53-
parent.ClearChildren();
54-
s.Delete(parent);
55-
}
56-
foreach (IChild child in children)
57-
{
58-
s.Delete(child);
59-
}
60-
61-
tx.Commit();
62-
}
45+
s.Delete("from System.Object");
46+
tx.Commit();
6347
}
64-
base.OnTearDown();
6548
}
6649

6750
[Test]

‎src/NHibernate.Test/Async/Hql/Ast/HqlFixture.cs

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -306,5 +306,14 @@ public async Task UnaryMinusBeforeParenthesesHandledCorrectlyAsync()
306306
Assert.That(actualWorkaround, Is.EqualTo(-2));
307307
}
308308
}
309+
310+
//NH-3249 (GH-1285)
311+
[Test]
312+
public async Task CountDistinctOnFunctionAsync()
313+
{
314+
var hql = @"SELECT COUNT(DISTINCT DATE(m.birthdate)) FROM Mammal m";
315+
using(var s = OpenSession())
316+
await (s.CreateQuery(hql).ListAsync());
317+
}
309318
}
310319
}

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

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,21 @@ public async Task CountDistinctProperty_ReturnsNumberOfDistinctEntriesForThatPro
4040
Assert.That(result, Is.EqualTo(387));
4141
}
4242

43+
//NH-3249 (GH-1285)
44+
[Test]
45+
public async Task CountDistinctFunc_ReturnsNumberOfDistinctEntriesForThatFuncAsync()
46+
{
47+
if (!TestDialect.SupportsCountDistinct)
48+
Assert.Ignore("Dialect does not support count distinct");
49+
50+
var result = await (db.Orders
51+
.Select(x => x.ShippingDate.Value.Date)
52+
.Distinct()
53+
.CountAsync());
54+
55+
Assert.That(result, Is.EqualTo(387));
56+
}
57+
4358
[Test]
4459
public async Task CountProperty_ReturnsNumberOfNonNullEntriesForThatPropertyAsync()
4560
{

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

Lines changed: 226 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -381,5 +381,231 @@ public async Task WhereAfterFetchAndSingleOrDefaultAsync()
381381

382382
Assert.IsTrue(NHibernateUtil.IsInitialized(order.Shipper));
383383
}
384+
385+
[Test]
386+
public async Task WhereReuseJoinsAsync()
387+
{
388+
OrderLine orderLine;
389+
using (var logSpy = new SqlLogSpy())
390+
{
391+
orderLine = (await (db.OrderLines
392+
.Where(o => o.Order.Customer.ContactName == "Maria Anders")
393+
.Fetch(o => o.Order).ThenFetch(o => o.Customer)
394+
.ToListAsync()))
395+
.First();
396+
397+
var sql = logSpy.GetWholeLog();
398+
Assert.That(GetTotalOccurrences(sql, "join"), Is.EqualTo(2));
399+
Assert.That(GetTotalOccurrences(sql, "inner join"), Is.EqualTo(2));
400+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order), Is.True);
401+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order.Customer), Is.True);
402+
}
403+
404+
session.Clear();
405+
using (var logSpy = new SqlLogSpy())
406+
{
407+
orderLine = (await (db.OrderLines
408+
.Where(o => o.Order.Customer.ContactName == "Maria Anders")
409+
.Fetch(o => o.Order)
410+
.ToListAsync()))
411+
.First();
412+
413+
var sql = logSpy.GetWholeLog();
414+
Assert.That(GetTotalOccurrences(sql, "join"), Is.EqualTo(2));
415+
Assert.That(GetTotalOccurrences(sql, "inner join"), Is.EqualTo(2));
416+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order), Is.True);
417+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order.Customer), Is.False);
418+
}
419+
420+
session.Clear();
421+
using (var logSpy = new SqlLogSpy())
422+
{
423+
orderLine = (await (db.OrderLines
424+
.Where(o => o.Order.OrderLines.Any(l => l.Product.Name == "Tofu"))
425+
.Fetch(o => o.Order).ThenFetch(o => o.Customer)
426+
.ToListAsync()))
427+
.First();
428+
429+
var sql = logSpy.GetWholeLog();
430+
sql = sql.Substring(0, sql.IndexOf("where"));
431+
Assert.That(GetTotalOccurrences(sql, "join"), Is.EqualTo(2));
432+
Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(2));
433+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order), Is.True);
434+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order.Customer), Is.True);
435+
}
436+
437+
using (var logSpy = new SqlLogSpy())
438+
{
439+
(await (db.Employees
440+
.Where(o => o.Superior.Superior.Superior.FirstName != null)
441+
.Fetch(o => o.Superior)
442+
.ToListAsync()))
443+
.FirstOrDefault();
444+
445+
var sql = logSpy.GetWholeLog();
446+
Assert.That(GetTotalOccurrences(sql, ","), Is.EqualTo(31), "Only the first level should be fetched.");
447+
Assert.That(GetTotalOccurrences(sql, "join"), Is.EqualTo(3));
448+
Assert.That(GetTotalOccurrences(sql, "inner join"), Is.EqualTo(3));
449+
}
450+
451+
using (var logSpy = new SqlLogSpy())
452+
{
453+
(await (db.Employees
454+
.Where(o => o.Superior.FirstName != null)
455+
.Fetch(o => o.Superior).ThenFetch(o => o.Superior).ThenFetch(o => o.Superior)
456+
.ToListAsync()))
457+
.FirstOrDefault();
458+
459+
var sql = logSpy.GetWholeLog();
460+
Assert.That(GetTotalOccurrences(sql, "join"), Is.EqualTo(3));
461+
Assert.That(GetTotalOccurrences(sql, "inner join"), Is.EqualTo(1));
462+
Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(2));
463+
}
464+
}
465+
466+
[Test]
467+
public async Task OrderByReuseJoinsAsync()
468+
{
469+
OrderLine orderLine;
470+
using (var logSpy = new SqlLogSpy())
471+
{
472+
orderLine = (await (db.OrderLines
473+
.Where(o => o.Order.OrderId == 10248)
474+
.OrderBy(o => o.Order.Customer.ContactName)
475+
.Fetch(o => o.Order).ThenFetch(o => o.Customer)
476+
.ToListAsync()))
477+
.First();
478+
479+
var sql = logSpy.GetWholeLog();
480+
Assert.That(GetTotalOccurrences(sql, "join"), Is.EqualTo(2));
481+
Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(2));
482+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order), Is.True);
483+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order.Customer), Is.True);
484+
}
485+
486+
session.Clear();
487+
using (var logSpy = new SqlLogSpy())
488+
{
489+
orderLine = (await (db.OrderLines
490+
.Where(o => o.Order.OrderId == 10248)
491+
.OrderBy(o => o.Order.Customer.ContactName)
492+
.Fetch(o => o.Order)
493+
.ToListAsync()))
494+
.First();
495+
496+
var sql = logSpy.GetWholeLog();
497+
Assert.That(GetTotalOccurrences(sql, "join"), Is.EqualTo(2));
498+
Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(2));
499+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order), Is.True);
500+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order.Customer), Is.False);
501+
}
502+
503+
using (var logSpy = new SqlLogSpy())
504+
{
505+
(await (db.Employees
506+
.OrderBy(o => o.Superior.Superior.Superior.FirstName)
507+
.Fetch(o => o.Superior)
508+
.ToListAsync()))
509+
.FirstOrDefault();
510+
511+
var sql = logSpy.GetWholeLog();
512+
Assert.That(GetTotalOccurrences(sql, ","), Is.EqualTo(31), "Only the first level should be fetched.");
513+
Assert.That(GetTotalOccurrences(sql, "join"), Is.EqualTo(3));
514+
Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(3));
515+
}
516+
517+
using (var logSpy = new SqlLogSpy())
518+
{
519+
(await (db.Employees
520+
.OrderBy(o => o.Superior.FirstName)
521+
.Fetch(o => o.Superior).ThenFetch(o => o.Superior).ThenFetch(o => o.Superior)
522+
.ToListAsync()))
523+
.FirstOrDefault();
524+
525+
var sql = logSpy.GetWholeLog();
526+
Assert.That(GetTotalOccurrences(sql, "join"), Is.EqualTo(3));
527+
Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(3));
528+
}
529+
}
530+
531+
[Test]
532+
public async Task WhereAndOrderByReuseJoinsAsync()
533+
{
534+
OrderLine orderLine;
535+
using (var logSpy = new SqlLogSpy())
536+
{
537+
orderLine = (await (db.OrderLines
538+
.Where(o => o.Order.Customer.ContactName == "Maria Anders")
539+
.OrderBy(o => o.Order.Customer.ContactName)
540+
.Fetch(o => o.Order).ThenFetch(o => o.Customer)
541+
.ToListAsync()))
542+
.First();
543+
544+
var sql = logSpy.GetWholeLog();
545+
Assert.That(GetTotalOccurrences(sql, "join"), Is.EqualTo(2));
546+
Assert.That(GetTotalOccurrences(sql, "inner join"), Is.EqualTo(2));
547+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order), Is.True);
548+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order.Customer), Is.True);
549+
}
550+
551+
session.Clear();
552+
using (var logSpy = new SqlLogSpy())
553+
{
554+
orderLine = (await (db.OrderLines
555+
.Where(o => o.Order.Customer.ContactName == "Maria Anders")
556+
.OrderBy(o => o.Order.Customer.ContactName)
557+
.Fetch(o => o.Order)
558+
.ToListAsync()))
559+
.First();
560+
561+
var sql = logSpy.GetWholeLog();
562+
Assert.That(GetTotalOccurrences(sql, "join"), Is.EqualTo(2));
563+
Assert.That(GetTotalOccurrences(sql, "inner join"), Is.EqualTo(2));
564+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order), Is.True);
565+
Assert.That(NHibernateUtil.IsInitialized(orderLine.Order.Customer), Is.False);
566+
}
567+
568+
using (var logSpy = new SqlLogSpy())
569+
{
570+
(await (db.Employees
571+
.Where(o => o.Superior.Superior.Superior.FirstName != null)
572+
.OrderBy(o => o.Superior.Superior.Superior.FirstName)
573+
.Fetch(o => o.Superior)
574+
.ToListAsync()))
575+
.FirstOrDefault();
576+
577+
var sql = logSpy.GetWholeLog();
578+
Assert.That(GetTotalOccurrences(sql, ","), Is.EqualTo(31), "Only the first level should be fetched.");
579+
Assert.That(GetTotalOccurrences(sql, "join"), Is.EqualTo(3));
580+
Assert.That(GetTotalOccurrences(sql, "inner join"), Is.EqualTo(3));
581+
}
582+
583+
using (var logSpy = new SqlLogSpy())
584+
{
585+
(await (db.Employees
586+
.Where(o => o.Superior.FirstName != null)
587+
.OrderBy(o => o.Superior.FirstName)
588+
.Fetch(o => o.Superior).ThenFetch(o => o.Superior).ThenFetch(o => o.Superior)
589+
.ToListAsync()))
590+
.FirstOrDefault();
591+
592+
var sql = logSpy.GetWholeLog();
593+
Assert.That(GetTotalOccurrences(sql, "join"), Is.EqualTo(3));
594+
Assert.That(GetTotalOccurrences(sql, "inner join"), Is.EqualTo(1));
595+
Assert.That(GetTotalOccurrences(sql, "left outer join"), Is.EqualTo(2));
596+
}
597+
}
598+
599+
[Test]
600+
public async Task FetchBeforeSelectAsync()
601+
{
602+
var result = await (db.Orders
603+
.Where(o => o.OrderId == 10248)
604+
.Fetch(x => x.Customer)
605+
.Select(x => new {x.Customer.ContactName})
606+
.ToListAsync());
607+
608+
Assert.True(result.Any());
609+
}
384610
}
385611
}

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

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -62,6 +62,14 @@ public async Task CanQueryOnEnumStoredAsString_Small_1Async()
6262
Assert.AreEqual(expectedCount, query.Count);
6363
}
6464

65+
[Test]
66+
public async Task CanQueryWithContainsOnEnumStoredAsString_Small_1Async()
67+
{
68+
var values = new[] { EnumStoredAsString.Small, EnumStoredAsString.Medium };
69+
var query = await (db.Users.Where(x => values.Contains(x.Enum1)).ToListAsync());
70+
Assert.AreEqual(3, query.Count);
71+
}
72+
6573
[Test]
6674
public async Task ConditionalNavigationPropertyAsync()
6775
{

0 commit comments

Comments
 (0)