Merge branch 'NH-2380'

Author: hazzik

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

@@ -22,8 +22,6 @@ public void CountDistinctProperty_ReturnsNumberOfDistinctEntriesForThatProperty(
 				.Distinct()
 				.Count();
 
-			Console.WriteLine(result);
-
 			Assert.That(result, Is.EqualTo(387));
 		}
 
@@ -35,8 +33,6 @@ public void CountProperty_ReturnsNumberOfNonNullEntriesForThatProperty()
 				.Select(x => x.ShippingDate)
 				.Count();
 
-			Console.WriteLine(result);
-
 			Assert.That(result, Is.EqualTo(809));
 		}
 

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

@@ -0,0 +1,134 @@
+using System;
+using System.Linq;
+using NHibernate.Cfg;
+using NUnit.Framework;
+using SharpTestsEx;
+
+namespace NHibernate.Test.Linq.ByMethod
+{
+	[TestFixture]
+	public class DistinctTests : LinqTestCase
+	{
+		public class OrderDto
+		{
+			public string ShipCountry { get; set; }
+			public DateTime? ShippingDate { get; set; }
+			public DateTime? OrderDate { get; set; }
+		}
+
+		private static T Transform<T>(T value)
+		{
+			return value;
+		}
+
+		[Test]
+		public void DistinctOnAnonymousTypeProjection()
+		{
+			//NH-2380
+			var result = db.Orders
+				.Select(x => new {x.ShippingDate})
+				.Distinct()
+				.ToArray();
+
+			result.Length.Should().Be.EqualTo(388);
+		}
+
+		[Test]
+		public void DistinctOnComplexAnonymousTypeProjection()
+		{
+			//NH-2380
+			var result = db.Orders
+				.Select(x => new
+								 {
+									 x.ShippingDate,
+									 x.OrderDate
+								 })
+				.Distinct()
+				.ToArray();
+
+			result.Length.Should().Be.EqualTo(774);
+		}
+
+		[Test]
+		public void DistinctOnTypeProjection()
+		{
+			//NH-2486
+			OrderDto[] result = db.Orders
+				.Select(x => new OrderDto
+								 {
+									 ShippingDate = x.ShippingDate
+								 })
+				.Distinct()
+				.ToArray();
+
+			result.Length.Should().Be.EqualTo(388);
+		}
+
+		[Test]
+		public void DistinctOnTypeProjectionTwoProperty()
+		{
+			//NH-2486
+			OrderDto[] result = db.Orders
+				.Select(x => new OrderDto
+								 {
+									 ShippingDate = x.ShippingDate,
+									 OrderDate = x.OrderDate
+								 })
+				.Distinct()
+				.ToArray();
+
+			result.Length.Should().Be.EqualTo(774);
+		}
+
+		[Test]
+		public void DistinctOnTypeProjectionWithHqlMethodIsOk()
+		{
+			// Sort of related to NH-2645.
+
+			OrderDto[] result = db.Orders
+				.Select(x => new OrderDto
+				{
+					ShipCountry = x.ShippingAddress.Country.ToLower(),     // Should be translated to HQL/SQL.
+					ShippingDate = x.ShippingDate,
+					OrderDate = x.OrderDate.Value.Date,
+				})
+				.Distinct()
+				.ToArray();
+
+			result.Length.Should().Be.EqualTo(824);
+		}
+
+		[Test]
+		[ExpectedException(typeof(NotSupportedException), ExpectedMessage = "Cannot use distinct on result that depends on methods for which no SQL equivalent exist.")]
+		public void DistinctOnTypeProjectionWithCustomProjectionMethodsIsBlocked1()
+		{
+			// Sort of related to NH-2645.
+
+			OrderDto[] result = db.Orders
+				.Select(x => new OrderDto
+								 {
+									 ShippingDate = Transform(x.ShippingDate),
+									 OrderDate = Transform(x.OrderDate)
+								 })
+				.Distinct()
+				.ToArray();
+		}
+
+
+		[Test]
+		[ExpectedException(typeof(NotSupportedException), ExpectedMessage = "Cannot use distinct on result that depends on methods for which no SQL equivalent exist.")]
+		public void DistinctOnTypeProjectionWithCustomProjectionMethodsIsBlocked2()
+		{
+			// Sort of related to NH-2645.
+
+			OrderDto[] result = db.Orders
+				.Select(x => new OrderDto
+				{
+					ShippingDate = x.ShippingDate,
+					OrderDate = x.OrderDate.Value.AddMonths(5),  // As of 2012-01-25, AddMonths() is executed locally.
+				})
+				.Distinct()
+				.ToArray();
+		}
+	}
+}

src/NHibernate.Test/NHibernate.Test.csproj

@@ -684,6 +684,7 @@
     <Compile Include="NHSpecificTest\AccessAndCorrectPropertyName\Model.cs" />
     <Compile Include="NHSpecificTest\BagWithLazyExtraAndFilter\Domain.cs" />
     <Compile Include="NHSpecificTest\BagWithLazyExtraAndFilter\Fixture.cs" />
+    <Compile Include="Linq\ByMethod\DistinctTests.cs" />
     <Compile Include="Component\Basic\ComponentWithUniqueConstraintTests.cs" />
     <Compile Include="NHSpecificTest\NH1082\SynchronizationThatThrowsExceptionAtBeforeTransactionCompletion.cs" />
     <Compile Include="NHSpecificTest\NH2756\Fixture.cs" />

src/NHibernate/Linq/Visitors/SelectClauseNominator.cs

@@ -6,11 +6,27 @@
 
 namespace NHibernate.Linq.Visitors
 {
+	/// <summary>
+	/// Analyze the select clause to determine what parts can be translated
+	/// fully to HQL, and some other properties of the clause.
+	/// </summary>
 	class SelectClauseHqlNominator : ExpressionTreeVisitor
 	{
 		private readonly ILinqToHqlGeneratorsRegistry _functionRegistry;
 
-		private HashSet<Expression> _candidates;
+		/// <summary>
+		/// The expression parts that can be converted to pure HQL.
+		/// </summary>
+		public HashSet<Expression> HqlCandidates { get; private set; }
+
+		/// <summary>
+		/// If true after an expression have been analyzed, the
+		/// expression as a whole contain at least one method call which
+		/// cannot be converted to a registered function, i.e. it must
+		/// be executed client side.
+		/// </summary>
+		public bool ContainsUntranslatedMethodCalls { get; private set; }
+
 		private bool _canBeCandidate;
 		Stack<bool> _stateStack;
 
@@ -19,16 +35,15 @@ public SelectClauseHqlNominator(VisitorParameters parameters)
 			_functionRegistry = parameters.SessionFactory.Settings.LinqToHqlGeneratorsRegistry;
 		}
 
-		internal HashSet<Expression> Nominate(Expression expression)
+		internal void Visit(Expression expression)
 		{
-			_candidates = new HashSet<Expression>();
+			HqlCandidates = new HashSet<Expression>();
+			ContainsUntranslatedMethodCalls = false;
 			_canBeCandidate = true;
 			_stateStack = new Stack<bool>();
 			_stateStack.Push(false);
 
 			VisitExpression(expression);
-
-			return _candidates;
 		}
 
 		public override Expression VisitExpression(Expression expression)
@@ -38,6 +53,17 @@ public override Expression VisitExpression(Expression expression)
 				var projectConstantsInHql = _stateStack.Peek() ||
 											expression != null && IsRegisteredFunction(expression);
 
+				// Set some flags, unless we already have proper values for them:
+				//    projectConstantsInHql if they are inside a method call executed server side.
+				//    ContainsUntranslatedMethodCalls if a method call must be executed locally.
+				var isMethodCall = expression != null && expression.NodeType == ExpressionType.Call;
+				if (isMethodCall && (!projectConstantsInHql || !ContainsUntranslatedMethodCalls))
+				{
+					var isRegisteredFunction = IsRegisteredFunction(expression);
+					projectConstantsInHql = projectConstantsInHql || isRegisteredFunction;
+					ContainsUntranslatedMethodCalls = ContainsUntranslatedMethodCalls || !isRegisteredFunction;
+				}
+
 				_stateStack.Push(projectConstantsInHql);
 
 				if (expression == null)
@@ -49,7 +75,7 @@ public override Expression VisitExpression(Expression expression)
 
 				if (CanBeEvaluatedInHqlStatementShortcut(expression))
 				{
-					_candidates.Add(expression);
+					HqlCandidates.Add(expression);
 					return expression;
 				}
 
@@ -59,7 +85,7 @@ public override Expression VisitExpression(Expression expression)
 				{
 					if (CanBeEvaluatedInHqlSelectStatement(expression, projectConstantsInHql))
 					{
-						_candidates.Add(expression);
+						HqlCandidates.Add(expression);
 					}
 					else
 					{

src/NHibernate/Linq/Visitors/SelectClauseVisitor.cs

@@ -1,23 +1,28 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using NHibernate.Hql.Ast;
+using NHibernate.Linq.Expressions;
 using Remotion.Linq.Parsing;
 
 namespace NHibernate.Linq.Visitors
 {
 	public class SelectClauseVisitor : ExpressionTreeVisitor
 	{
+		private readonly HqlTreeBuilder _hqlTreeBuilder = new HqlTreeBuilder();
 		private HashSet<Expression> _hqlNodes;
 		private readonly ParameterExpression _inputParameter;
 		private readonly VisitorParameters _parameters;
 		private int _iColumn;
 		private List<HqlExpression> _hqlTreeNodes = new List<HqlExpression>();
+		private readonly HqlGeneratorExpressionTreeVisitor _hqlVisitor;
 
 		public SelectClauseVisitor(System.Type inputType, VisitorParameters parameters)
 		{
 			_inputParameter = Expression.Parameter(inputType, "input");
 			_parameters = parameters;
+			_hqlVisitor = new HqlGeneratorExpressionTreeVisitor(_parameters);
 		}
 
 		public LambdaExpression ProjectionExpression { get; private set; }
@@ -29,19 +34,41 @@ public IEnumerable<HqlExpression> GetHqlNodes()
 
 		public void Visit(Expression expression)
 		{
-			// First, find the sub trees that can be expressed purely in HQL
-			_hqlNodes = new SelectClauseHqlNominator(_parameters).Nominate(expression);
+			var distinct = expression as NhDistinctExpression;
+			if (distinct != null)
+			{
+				expression = distinct.Expression;
+			}
+
+			// Find the sub trees that can be expressed purely in HQL
+			var nominator = new SelectClauseHqlNominator(_parameters);
+			nominator.Visit(expression);
+			_hqlNodes = nominator.HqlCandidates;
+
+			// Linq2SQL ignores calls to local methods. Linq2EF seems to not support
+			// calls to local methods at all. For NHibernate we support local methods,
+			// but prevent their use together with server-side distinct, since it may
+			// end up being wrong.
+			if (distinct != null && nominator.ContainsUntranslatedMethodCalls)
+				throw new NotSupportedException("Cannot use distinct on result that depends on methods for which no SQL equivalent exist.");
 
 			// Now visit the tree
-			Expression projection = VisitExpression(expression);
+			var projection = VisitExpression(expression);
 
 			if ((projection != expression) && !_hqlNodes.Contains(expression))
 			{
 				ProjectionExpression = Expression.Lambda(projection, _inputParameter);
 			}
 
-			// Finally, handle any boolean results in the output nodes
+			// Handle any boolean results in the output nodes
 			_hqlTreeNodes = BooleanToCaseConvertor.Convert(_hqlTreeNodes).ToList();
+
+			if (distinct != null)
+			{
+				var treeNodes = new List<HqlTreeNode>(_hqlTreeNodes.Count + 1) {_hqlTreeBuilder.Distinct()};
+				treeNodes.AddRange(_hqlTreeNodes);
+				_hqlTreeNodes = new List<HqlExpression>(1) {_hqlTreeBuilder.ExpressionSubTreeHolder(treeNodes)};
+			}
 		}
 
 		public override Expression VisitExpression(Expression expression)
@@ -53,13 +80,10 @@ public override Expression VisitExpression(Expression expression)
 
 			if (_hqlNodes.Contains(expression))
 			{
-				// Pure HQL evaluation - TODO - cache the Visitor?
-				var hqlVisitor = new HqlGeneratorExpressionTreeVisitor(_parameters);
-
-				_hqlTreeNodes.Add(hqlVisitor.Visit(expression).AsExpression());
+				// Pure HQL evaluation
+				_hqlTreeNodes.Add(_hqlVisitor.Visit(expression).AsExpression());
 
-				return Expression.Convert(
-					Expression.ArrayIndex(_inputParameter, Expression.Constant(_iColumn++)), expression.Type);
+				return Expression.Convert(Expression.ArrayIndex(_inputParameter, Expression.Constant(_iColumn++)), expression.Type);
 			}
 
 			// Can't handle this node with HQL.  Just recurse down, and emit the expression

src/NHibernate/Persister/Collection/AbstractCollectionPersister.cs

@@ -853,8 +853,8 @@ private SqlString GenerateSelectSizeString(ISessionImplementor sessionImplemento
 		protected virtual string GetCountSqlSelectClause()
 		{
 			// NH: too many "if" when each collection can have its persister
-			if (isCollectionIntegerIndex) return string.Format("coalesce(max({0}) + 1, 0)", IndexColumnNames[0]); // Do we need this "optimization"?
-			return string.Format("count({0})", HasIndex ? GetIndexCountExpression() : ElementColumnNames[0]);
+			if (isCollectionIntegerIndex) return string.Format("coalesce(max({0}) + 1, 0)", IndexColumnNames[0]); // Do we need this "optimization"?
+			return string.Format("count({0})", HasIndex ? GetIndexCountExpression() : ElementColumnNames[0]);
 		}
 
 		private string GetIndexCountExpression()