NH-3100 - Implement correct semantic for equal and not equal considering null behaviours

src/NHibernate.Test/Linq/FunctionTests.cs

@@ -331,6 +331,16 @@ where item.IsActive.Equals(true)
 			ObjectDumper.Write(query);
 		}
 
+		[Test]
+		public void WhereBoolConditionEquals()
+		{
+			var query = from item in db.Role
+						where item.IsActive.Equals(item.Name != null)
+						select item;
+
+			ObjectDumper.Write(query);
+		}
+
 		[Test]
 		public void WhereBoolParameterEqual()
 		{

src/NHibernate.Test/Linq/LinqQuerySamples.cs

@@ -1498,6 +1498,18 @@ from c in db.Customers
 			ObjectDumper.Write(q);
 		}
 
+		[Category("JOIN")]
+		[Test(Description = "This sample explictly joins two tables with a composite key and projects results from both tables.")]
+		public void DLinqJoin5d()
+		{
+			var q =
+				from c in db.Customers
+				join o in db.Orders on new {c.CustomerId, HasContractTitle = c.ContactTitle != null} equals new {o.Customer.CustomerId, HasContractTitle = o.Customer.ContactTitle != null }
+				select new { c.ContactName, o.OrderId };
+
+			ObjectDumper.Write(q);
+		}
+
 		[Category("JOIN")]
 		[Test(Description = "This sample explictly joins three tables and projects results from each of them.")]
 		public void DLinqJoin6()

src/NHibernate.Test/Linq/NullComparisonTests.cs

@@ -84,7 +84,7 @@ public void NullEquality()
 
 			// Columns against columns
 			q = from x in session.Query<AnotherEntity>() where x.Input == x.Output select x;
-			Expect(q, BothSame);
+			Expect(q, BothSame, BothNull);
 		}
 
 		[Test]
@@ -134,15 +134,15 @@ public void NullInequality()
 			q = from x in session.Query<AnotherEntity>() where nullVariable != x.Input select x;
 			ExpectInputIsNotNull(q);
 			q = from x in session.Query<AnotherEntity>() where notNullVariable != x.Input select x;
-			Expect(q, BothSame);
+			Expect(q, BothSame, BothNull, OutputSet);
 			q = from x in session.Query<AnotherEntity>() where x.Input != nullVariable select x;
 			ExpectInputIsNotNull(q);
 			q = from x in session.Query<AnotherEntity>() where x.Input != notNullVariable select x;
-			Expect(q, BothSame);
+			Expect(q, BothSame, OutputSet, BothNull);
 
 			// Columns against columns
 			q = from x in session.Query<AnotherEntity>() where x.Input != x.Output select x;
-			Expect(q, BothDifferent);
+			Expect(q, BothDifferent, InputSet, OutputSet);
 		}
 
 		[Test]

src/NHibernate.Test/Linq/WhereTests.cs

@@ -379,18 +379,21 @@ public void ProductWithDoubleStringContainsAndNotNull()
 			var nullAsNullableBool = Expression.Constant(null, typeof(bool?));
 			var valueProperty = typeof (bool?).GetProperty("Value");
 
-			var quantityIsNull = ((Expression<Func<Product, bool>>)(x => x.QuantityPerUnit == null));
-			var nameIsNull = ((Expression<Func<Product, bool>>)(x => x.Name == null));
+			Expression<Func<Product, bool>> quantityIsNull = x => x.QuantityPerUnit == null;
+			Expression<Func<Product, bool>> nameIsNull = x => x.Name == null;
 
-			var quantityContains23 = ((Expression<Func<Product, bool?>>)(x => x.QuantityPerUnit.Contains("box")));
-			var nameContains2 = ((Expression<Func<Product, bool?>>)(x => x.Name.Contains("Cha")));
+			Expression<Func<Product, bool?>> quantityContains23 = x => x.QuantityPerUnit.Contains("box");
+			Expression<Func<Product, bool?>> nameContains2 = x => x.Name.Contains("Cha");
 
-			var conjunction = Expression.AndAlso(Expression.Condition(quantityIsNull.Body, nullAsNullableBool, quantityContains23.Body),
-												 Expression.Condition(nameIsNull.Body, nullAsNullableBool, nameContains2.Body));
+			var conjunction = Expression.AndAlso(
+				Expression.Condition(quantityIsNull.Body, nullAsNullableBool, quantityContains23.Body),
+				Expression.Condition(nameIsNull.Body, nullAsNullableBool, nameContains2.Body)
+			);
 
-			var condition = Expression.Condition(Expression.Equal(conjunction, Expression.Constant(null)),
-												 Expression.Constant(false),
-												 Expression.MakeMemberAccess(conjunction, valueProperty));
+			var condition = Expression.Condition(
+				Expression.Equal(conjunction, Expression.Constant(null)),
+				Expression.Constant(false),
+				Expression.MakeMemberAccess(conjunction, valueProperty));
 
 			var expr = Expression.Lambda<Func<Product, bool>>(condition, quantityIsNull.Parameters);
 

src/NHibernate.Test/NHSpecificTest/NH2505/Fixture.cs

@@ -36,6 +36,7 @@ public Scenario(ISessionFactory factory)
 				{
 					session.Save(new MyClass { Alive = true });
 					session.Save(new MyClass { Alive = false, MayBeAlive = true });
+					session.Save(new MyClass { Alive = false, MayBeAlive = false });
 					session.Flush();
 				}
 			}
@@ -51,7 +52,7 @@ public void Dispose()
 		}
 
 		[Test]
-		public void WhenQueryConstantEqualToMemberThenDoesNotUseTheCaseConstructor()
+		public void WhenQueryConstantEqualToMemberThenDoNotUseCaseStatement()
 		{
 			using (new Scenario(Sfi))
 			{
@@ -60,7 +61,7 @@ public void WhenQueryConstantEqualToMemberThenDoesNotUseTheCaseConstructor()
 					using (var sqls = new SqlLogSpy())
 					{
 						var list = session.Query<MyClass>().Where(x => x.Alive == false).ToList();
-						Assert.That(list, Has.Count.EqualTo(1));
+						Assert.That(list, Has.Count.EqualTo(2));
 						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(0));
 					}
 					using (var sqls = new SqlLogSpy())
@@ -74,28 +75,30 @@ public void WhenQueryConstantEqualToMemberThenDoesNotUseTheCaseConstructor()
 		}
 
 		[Test]
-		public void WhenQueryConstantNotEqualToMemberThenDoesNotUseTheCaseConstructor()
+		public void WhenQueryConstantNotEqualToMemberThenDoNotUseCaseStatement()
 		{
 			using (new Scenario(Sfi))
 			{
 				using (var session = OpenSession())
 				{
 					using (var sqls = new SqlLogSpy())
 					{
-						Assert.That(session.Query<MyClass>().Where(x => x.Alive != false).ToList(), Has.Count.EqualTo(1));
+						var list = session.Query<MyClass>().Where(x => x.Alive != false).ToList();
+						Assert.That(list, Has.Count.EqualTo(1));
 						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(0));
 					}
 					using (var sqls = new SqlLogSpy())
 					{
-						Assert.That(session.Query<MyClass>().Where(x => true != x.Alive).ToList(), Has.Count.EqualTo(1));
+						var list = session.Query<MyClass>().Where(x => true != x.Alive).ToList();
+						Assert.That(list, Has.Count.EqualTo(2));
 						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(0));
 					}
 				}
 			}
 		}
 
 		[Test]
-		public void WhenQueryComplexEqualToComplexThentUseTheCaseConstructorForBoth()
+		public void WhenQueryComplexEqualToComplexThentUseTheCaseStatementForBoth()
 		{
 			using (new Scenario(Sfi))
 			{
@@ -111,63 +114,69 @@ public void WhenQueryComplexEqualToComplexThentUseTheCaseConstructorForBoth()
 		}
 
 		[Test]
-		public void WhenQueryConstantEqualToNullableMemberThenUseTheCaseConstructorForMember()
+		public void WhenQueryConstantEqualToNullableMemberThenDoNotUseCaseStatement()
 		{
 			using (new Scenario(Sfi))
 			{
 				using (var session = OpenSession())
 				{
 					using (var sqls = new SqlLogSpy())
 					{
-						Assert.That(session.Query<MyClass>().Where(x => x.MayBeAlive == false).ToList(), Has.Count.EqualTo(1));
-						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(1));
+						var list = session.Query<MyClass>().Where(x => x.MayBeAlive == false).ToList();
+						Assert.That(list, Has.Count.EqualTo(1));
+						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(0));
 					}
 					using (var sqls = new SqlLogSpy())
 					{
-						Assert.That(session.Query<MyClass>().Where(x => true == x.MayBeAlive).ToList(), Has.Count.EqualTo(1));
-						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(1));
+						var list = session.Query<MyClass>().Where(x => true == x.MayBeAlive).ToList();
+						Assert.That(list, Has.Count.EqualTo(1));
+						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(0));
 					}
 				}
 			}
 		}
 
 		[Test]
-		public void WhenQueryConstantEqualToNullableMemberValueThenDoesNotUseTheCaseConstructorForMember()
+		public void WhenQueryConstantEqualToNullableMemberValueThenDoNotUseCaseStatement()
 		{
 			using (new Scenario(Sfi))
 			{
 				using (var session = OpenSession())
 				{
 					using (var sqls = new SqlLogSpy())
 					{
-						session.Query<MyClass>().Where(x => x.MayBeAlive.Value == false).ToList();
-						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(1));
+						var list = session.Query<MyClass>().Where(x => x.MayBeAlive.Value == false).ToList();
+						Assert.That(list, Has.Count.EqualTo(1));
+						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(0));
 					}
 					using (var sqls = new SqlLogSpy())
 					{
-						session.Query<MyClass>().Where(x => true == x.MayBeAlive.Value).ToList();
-						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(1));
+						var list = session.Query<MyClass>().Where(x => true == x.MayBeAlive.Value).ToList();
+						Assert.That(list, Has.Count.EqualTo(1));
+						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(0));
 					}
 				}
 			}
 		}
 
 		[Test]
-		public void WhenQueryConstantNotEqualToNullableMemberThenUseTheCaseConstructorForMember()
+		public void WhenQueryConstantNotEqualToNullableMemberThenDoNotUseCaseStatement()
 		{
 			using (new Scenario(Sfi))
 			{
 				using (var session = OpenSession())
 				{
 					using (var sqls = new SqlLogSpy())
 					{
-						Assert.That(session.Query<MyClass>().Where(x => x.MayBeAlive != false).ToList(), Has.Count.EqualTo(1));
-						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(1));
+						var list = session.Query<MyClass>().Where(x => x.MayBeAlive != false).ToList();
+						Assert.That(list, Has.Count.EqualTo(2));
+						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(0));
 					}
 					using (var sqls = new SqlLogSpy())
 					{
-						Assert.That(session.Query<MyClass>().Where(x => true != x.MayBeAlive).ToList(), Has.Count.EqualTo(1));
-						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(1));
+						var list = session.Query<MyClass>().Where(x => true != x.MayBeAlive).ToList();
+						Assert.That(list, Has.Count.EqualTo(2));
+						Assert.That(caseClause.Matches(sqls.GetWholeLog()).Count, Is.EqualTo(0));
 					}
 				}
 			}