NH-3474 - Fix ExpressionKeyVisitor handling of constant IEnumerables to show initialization values

Author: hazzik

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

@@ -595,22 +595,33 @@ public void GroupByKeyWithConstantFromVariable()
 		{
 			constKey = 1;
 			var q1 = db.Orders.GroupBy(o => constKey).Select(g => new {Key = g.Key, Count = g.Count(), Sum = g.Sum(x => x.Freight)});
+			var q1a = db.Orders.GroupBy(o => "").Select(g => new {Key = g.Key, Count = g.Count(), Sum = g.Sum(x => x.Freight)});
 			var q2 = db.Orders.GroupBy(o => new {A = constKey}).Select(g => new {Key = g.Key, Count = g.Count(), Sum = g.Sum(x => x.Freight)});
 			var q3 = db.Orders.GroupBy(o => new object[] {constKey}).Select(g => new {Key = g.Key, Count = g.Count(), Sum = g.Sum(x => x.Freight)});
+			var q3a = db.Orders.GroupBy(o => (IEnumerable<object>) new object[] {constKey}).Select(g => new {Key = g.Key, Count = g.Count(), Sum = g.Sum(x => x.Freight)});
 			var q4 = db.Orders.GroupBy(o => new {A = constKey, B = o.Shipper.ShipperId}).Select(g => new {Key = g.Key, Count = g.Count(), Sum = g.Sum(x => x.Freight)});
 			var q5 = db.Orders.GroupBy(o => new[] {constKey, o.Shipper.ShipperId}).Select(g => new {Key = g.Key, Count = g.Count(), Sum = g.Sum(x => x.Freight)});
+			var q5a = db.Orders.GroupBy(o => (IEnumerable<int>) new[] {constKey, o.Shipper.ShipperId}).Select(g => new {Key = g.Key, Count = g.Count(), Sum = g.Sum(x => x.Freight)});
 
 			var r1_1 = q1.ToList();
 			Assert.That(r1_1.Count, Is.EqualTo(1));
 			Assert.That(r1_1, Has.All.With.Property("Key").EqualTo(1));
 
+			var r1a_1 = q1a.ToList();
+			Assert.That(r1a_1.Count, Is.EqualTo(1));
+			Assert.That(r1a_1, Has.All.With.Property("Key").EqualTo(""));
+
 			var r2_1 = q2.ToList();
 			Assert.That(r2_1.Count, Is.EqualTo(1));
 			Assert.That(r2_1, Has.All.With.Property("Key").With.Property("A").EqualTo(1));
 
 			var r3_1 = q3.ToList();
 			Assert.That(r3_1.Count, Is.EqualTo(1));
-			Assert.That(r3_1, Has.All.With.Property("Key").EqualTo(new object[] { 1 }));
+			Assert.That(r3_1, Has.All.With.Property("Key").EquivalentTo(new object[] { 1 }));
+
+			var r3a_1 = q3a.ToList();
+			Assert.That(r3a_1.Count, Is.EqualTo(1));
+			Assert.That(r3a_1, Has.All.With.Property("Key").EquivalentTo(new object[] { 1 }));
 
 			var r4_1 = q4.ToList();
 			Assert.That(r4_1.Count, Is.EqualTo(3));
@@ -620,6 +631,10 @@ public void GroupByKeyWithConstantFromVariable()
 			Assert.That(r5_1.Count, Is.EqualTo(3));
 			Assert.That(r5_1, Has.All.With.Property("Key").Contains(1));
 
+			var r6_1 = q5a.ToList();
+			Assert.That(r6_1.Count, Is.EqualTo(3));
+			Assert.That(r6_1, Has.All.With.Property("Key").Contains(1));
+
 			constKey = 2;
 
 			var r1_2 = q1.ToList();
@@ -632,7 +647,11 @@ public void GroupByKeyWithConstantFromVariable()
 
 			var r3_2 = q3.ToList();
 			Assert.That(r3_2.Count, Is.EqualTo(1));
-			Assert.That(r3_2, Has.All.With.Property("Key").EqualTo(new object[] { constKey }));
+			Assert.That(r3_2, Has.All.With.Property("Key").EquivalentTo(new object[] { 2 }));
+
+			var r3a_2 = q3a.ToList();
+			Assert.That(r3a_2.Count, Is.EqualTo(1));
+			Assert.That(r3a_2, Has.All.With.Property("Key").EquivalentTo(new object[] { 2 }));
 
 			var r4_2 = q4.ToList();
 			Assert.That(r4_2.Count, Is.EqualTo(3));
@@ -641,6 +660,10 @@ public void GroupByKeyWithConstantFromVariable()
 			var r5_2 = q5.ToList();
 			Assert.That(r5_2.Count, Is.EqualTo(3));
 			Assert.That(r5_2, Has.All.With.Property("Key").Contains(2));
+
+			var r6_2 = q5.ToList();
+			Assert.That(r6_2.Count, Is.EqualTo(3));
+			Assert.That(r6_2, Has.All.With.Property("Key").Contains(2));
 		}
 
 		[Test(Description = "NH-3801")]

src/NHibernate/Linq/Visitors/ExpressionKeyVisitor.cs

@@ -84,30 +84,41 @@ protected override Expression VisitConstantExpression(ConstantExpression express
 			{
 				// Nulls generate different query plans.  X = variable generates a different query depending on if variable is null or not.
 				if (param.Value == null)
+				{
 					_string.Append("NULL");
-				if (param.Value is IEnumerable && !((IEnumerable)param.Value).Cast<object>().Any())
-					_string.Append("EmptyList");
+				}
 				else
-					_string.Append(param.Name);
+				{
+					var value = param.Value as IEnumerable;
+					if (value != null && !(value is string) && !value.Cast<object>().Any())
+					{
+						_string.Append("EmptyList");
+					}
+					else
+					{
+						_string.Append(param.Name);
+					}
+				}
 			}
 			else
 			{
 				if (expression.Value == null)
 				{
 					_string.Append("NULL");
 				}
-				else if (expression.Type.IsArray)
-				{
-					// Const arrays all look the same (they just display the type of array and not the initializer contents
-					// Since the contents might be different, we need to include those as well so we don't use a cached query plan by mistake
-					_string.Append(expression.Value);
-					_string.Append(" {");
-					_string.Append(String.Join(",", (object[]) expression.Value));
-					_string.Append("}");
-				}
 				else
 				{
-					_string.Append(expression.Value);
+					var value = expression.Value as IEnumerable;
+					if (value != null  && !(value is string) && !(value is IQueryable))
+					{
+						_string.Append("{");
+						_string.Append(String.Join(",", value.Cast<object>()));
+						_string.Append("}");
+					}
+					else
+					{
+						_string.Append(expression.Value);
+					}
 				}
 			}