Reduce cast usage for COUNT aggregate and add support for Mssql count_big (#2061)

maca88 · hazzik · web-flow · commit c0f50429722b · 2020-04-01T21:25:30.000+02:00
Co-authored-by: Alexander Zaytsev &lt;hazzik@gmail.com&gt;
diff --git a/src/NHibernate.Test/Async/Linq/ByMethod/CountTests.cs b/src/NHibernate.Test/Async/Linq/ByMethod/CountTests.cs
@@ -11,6 +11,7 @@
 using System;
 using System.Linq;
 using NHibernate.Cfg;
+using NHibernate.Dialect;
 using NUnit.Framework;
 using NHibernate.Linq;
 
@@ -110,5 +111,50 @@ into temp
 
 			Assert.That(result.Count, Is.EqualTo(77));
 		}
+
+		[Test]
+		public async Task CheckSqlFunctionNameLongCountAsync()
+		{
+			var name = Dialect is MsSql2000Dialect ? "count_big" : "count";
+			using (var sqlLog = new SqlLogSpy())
+			{
+				var result = await (db.Orders.LongCountAsync());
+				Assert.That(result, Is.EqualTo(830));
+
+				var log = sqlLog.GetWholeLog();
+				Assert.That(log, Does.Contain($"{name}("));
+			}
+		}
+
+		[Test]
+		public async Task CheckSqlFunctionNameForCountAsync()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			{
+				var result = await (db.Orders.CountAsync());
+				Assert.That(result, Is.EqualTo(830));
+
+				var log = sqlLog.GetWholeLog();
+				Assert.That(log, Does.Contain("count("));
+			}
+		}
+
+		[Test]
+		public async Task CheckMssqlCountCastAsync()
+		{
+			if (!(Dialect is MsSql2000Dialect))
+			{
+				Assert.Ignore();
+			}
+
+			using (var sqlLog = new SqlLogSpy())
+			{
+				var result = await (db.Orders.CountAsync());
+				Assert.That(result, Is.EqualTo(830));
+
+				var log = sqlLog.GetWholeLog();
+				Assert.That(log, Does.Not.Contain("cast("));
+			}
+		}
 	}
 }
diff --git a/src/NHibernate.Test/Linq/ByMethod/CountTests.cs b/src/NHibernate.Test/Linq/ByMethod/CountTests.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using System.Linq;
 using NHibernate.Cfg;
+using NHibernate.Dialect;
 using NUnit.Framework;
 
 namespace NHibernate.Test.Linq.ByMethod
@@ -98,5 +99,50 @@ into temp
 
 			Assert.That(result.Count, Is.EqualTo(77));
 		}
+
+		[Test]
+		public void CheckSqlFunctionNameLongCount()
+		{
+			var name = Dialect is MsSql2000Dialect ? "count_big" : "count";
+			using (var sqlLog = new SqlLogSpy())
+			{
+				var result = db.Orders.LongCount();
+				Assert.That(result, Is.EqualTo(830));
+
+				var log = sqlLog.GetWholeLog();
+				Assert.That(log, Does.Contain($"{name}("));
+			}
+		}
+
+		[Test]
+		public void CheckSqlFunctionNameForCount()
+		{
+			using (var sqlLog = new SqlLogSpy())
+			{
+				var result = db.Orders.Count();
+				Assert.That(result, Is.EqualTo(830));
+
+				var log = sqlLog.GetWholeLog();
+				Assert.That(log, Does.Contain("count("));
+			}
+		}
+
+		[Test]
+		public void CheckMssqlCountCast()
+		{
+			if (!(Dialect is MsSql2000Dialect))
+			{
+				Assert.Ignore();
+			}
+
+			using (var sqlLog = new SqlLogSpy())
+			{
+				var result = db.Orders.Count();
+				Assert.That(result, Is.EqualTo(830));
+
+				var log = sqlLog.GetWholeLog();
+				Assert.That(log, Does.Not.Contain("cast("));
+			}
+		}
 	}
 }
diff --git a/src/NHibernate/Dialect/Dialect.cs b/src/NHibernate/Dialect/Dialect.cs
@@ -55,6 +55,7 @@ public abstract partial class Dialect
 		static Dialect()
 		{
 			StandardAggregateFunctions["count"] = new CountQueryFunctionInfo();
+			StandardAggregateFunctions["count_big"] = new CountQueryFunctionInfo();
 			StandardAggregateFunctions["avg"] = new AvgQueryFunctionInfo();
 			StandardAggregateFunctions["max"] = new ClassicAggregateFunction("max", false);
 			StandardAggregateFunctions["min"] = new ClassicAggregateFunction("min", false);
diff --git a/src/NHibernate/Dialect/Function/ClassicAggregateFunction.cs b/src/NHibernate/Dialect/Function/ClassicAggregateFunction.cs
@@ -1,15 +1,15 @@
 using System;
 using System.Collections;
-using System.Text;
+using System.Collections.Generic;
+using System.Linq;
 using NHibernate.Engine;
 using NHibernate.SqlCommand;
 using NHibernate.Type;
-using NHibernate.Util;
 
 namespace NHibernate.Dialect.Function
 {
 	[Serializable]
-	public class ClassicAggregateFunction : ISQLFunction, IFunctionGrammar
+	public class ClassicAggregateFunction : ISQLFunction, IFunctionGrammar, ISQLFunctionExtended
 	{
 		private IType returnType = null;
 		private readonly string name;
@@ -45,6 +45,15 @@ public virtual IType ReturnType(IType columnType, IMapping mapping)
 			return returnType ?? columnType;
 		}
 
+		/// <inheritdoc />
+		public virtual IType GetEffectiveReturnType(IEnumerable<IType> argumentTypes, IMapping mapping, bool throwOnError)
+		{
+			return ReturnType(argumentTypes.FirstOrDefault(), mapping);
+		}
+
+		/// <inheritdoc />
+		public string FunctionName => name;
+
 		public bool HasArguments
 		{
 			get { return true; }
diff --git a/src/NHibernate/Dialect/Function/ISQLFunction.cs b/src/NHibernate/Dialect/Function/ISQLFunction.cs
@@ -1,4 +1,6 @@
 using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
 using NHibernate.Engine;
 using NHibernate.SqlCommand;
 using NHibernate.Type;
@@ -41,4 +43,45 @@ public interface ISQLFunction
 		/// <returns>SQL fragment for the function.</returns>
 		SqlString Render(IList args, ISessionFactoryImplementor factory);
 	}
+
+	// 6.0 TODO: Remove
+	internal static class SQLFunctionExtensions
+	{
+		/// <summary>
+		/// Get the type that will be effectively returned by the underlying database.
+		/// </summary>
+		/// <param name="sqlFunction">The sql function.</param>
+		/// <param name="argumentTypes">The types of arguments.</param>
+		/// <param name="mapping">The mapping for retrieving the argument sql types.</param>
+		/// <param name="throwOnError">Whether to throw when the number of arguments is invalid or they are not supported.</param>
+		/// <returns>The type returned by the underlying database or <see langword="null"/> when the number of arguments
+		/// is invalid or they are not supported.</returns>
+		/// <exception cref="QueryException">When <paramref name="throwOnError"/> is set to <see langword="true"/> and the
+		/// number of arguments is invalid or they are not supported.</exception>
+		public static IType GetEffectiveReturnType(
+			this ISQLFunction sqlFunction,
+			IEnumerable<IType> argumentTypes,
+			IMapping mapping,
+			bool throwOnError)
+		{
+			if (!(sqlFunction is ISQLFunctionExtended extendedSqlFunction))
+			{
+				try
+				{
+					return sqlFunction.ReturnType(argumentTypes.FirstOrDefault(), mapping);
+				}
+				catch (QueryException)
+				{
+					if (throwOnError)
+					{
+						throw;
+					}
+
+					return null;
+				}
+			}
+
+			return extendedSqlFunction.GetEffectiveReturnType(argumentTypes, mapping, throwOnError);
+		}
+	}
 }
diff --git a/src/NHibernate/Dialect/Function/ISQLFunctionExtended.cs b/src/NHibernate/Dialect/Function/ISQLFunctionExtended.cs
@@ -0,0 +1,27 @@
+﻿using System.Collections.Generic;
+using NHibernate.Engine;
+using NHibernate.Type;
+
+namespace NHibernate.Dialect.Function
+{
+	// 6.0 TODO: Merge into ISQLFunction
+	internal interface ISQLFunctionExtended : ISQLFunction
+	{
+		/// <summary>
+		/// The function name or <see langword="null"/> when multiple functions/operators/statements are used.
+		/// </summary>
+		string FunctionName { get; }
+
+		/// <summary>
+		/// Get the type that will be effectively returned by the underlying database.
+		/// </summary>
+		/// <param name="argumentTypes">The types of arguments.</param>
+		/// <param name="mapping">The mapping for retrieving the argument sql types.</param>
+		/// <param name="throwOnError">Whether to throw when the number of arguments is invalid or they are not supported.</param>
+		/// <returns>The type returned by the underlying database or <see langword="null"/> when the number of arguments
+		/// is invalid or they are not supported.</returns>
+		/// <exception cref="QueryException">When <paramref name="throwOnError"/> is set to <see langword="true"/> and the
+		/// number of arguments is invalid or they are not supported.</exception>
+		IType GetEffectiveReturnType(IEnumerable<IType> argumentTypes, IMapping mapping, bool throwOnError);
+	}
+}
diff --git a/src/NHibernate/Dialect/MsSql2000Dialect.cs b/src/NHibernate/Dialect/MsSql2000Dialect.cs
@@ -286,7 +286,8 @@ protected virtual void RegisterKeywords()
 
 		protected virtual void RegisterFunctions()
 		{
-			RegisterFunction("count", new CountBigQueryFunction());
+			RegisterFunction("count", new CountQueryFunction());
+			RegisterFunction("count_big", new CountBigQueryFunction());
 
 			RegisterFunction("abs", new StandardSQLFunction("abs"));
 			RegisterFunction("absval", new StandardSQLFunction("absval"));
@@ -704,11 +705,15 @@ protected virtual string GetSelectExistingObject(string catalog, string schema,
 		[Serializable]
 		protected class CountBigQueryFunction : ClassicAggregateFunction
 		{
-			public CountBigQueryFunction() : base("count_big", true) { }
+			public CountBigQueryFunction() : base("count_big", true, NHibernateUtil.Int64) { }
+		}
 
-			public override IType ReturnType(IType columnType, IMapping mapping)
+		[Serializable]
+		private class CountQueryFunction : CountQueryFunctionInfo
+		{
+			public override IType GetEffectiveReturnType(IEnumerable<IType> argumentTypes, IMapping mapping, bool throwOnError)
 			{
-				return NHibernateUtil.Int64;
+				return NHibernateUtil.Int32;
 			}
 		}
 
diff --git a/src/NHibernate/Hql/Ast/ANTLR/SqlGenerator.cs b/src/NHibernate/Hql/Ast/ANTLR/SqlGenerator.cs
@@ -310,6 +310,12 @@ private void EndFunctionTemplate(IASTNode m)
 			}
 		}
 
+		private void OutAggregateFunctionName(IASTNode m)
+		{
+			var aggregateNode = (AggregateNode) m;
+			Out(aggregateNode.FunctionName);
+		}
+
 		private void CommaBetweenParameters(String comma)
 		{
 			writer.CommaBetweenParameters(comma);
diff --git a/src/NHibernate/Hql/Ast/ANTLR/SqlGenerator.g b/src/NHibernate/Hql/Ast/ANTLR/SqlGenerator.g
@@ -150,7 +150,7 @@ selectExpr
 	;
 
 count
-	: ^(COUNT { Out("count("); }  ( distinctOrAll ) ? countExpr { Out(")"); } )
+	: ^(c=COUNT { OutAggregateFunctionName(c); Out("("); }  ( distinctOrAll ) ? countExpr { Out(")"); } )
 	;
 
 distinctOrAll
@@ -344,7 +344,7 @@ caseExpr
 	;
 
 aggregate
-	: ^(a=AGGREGATE { Out(a); Out("("); }  expr { Out(")"); } )
+	: ^(a=AGGREGATE { OutAggregateFunctionName(a); Out("("); }  expr { Out(")"); } )
 	;
 
 
diff --git a/src/NHibernate/Hql/Ast/ANTLR/Tree/AggregateNode.cs b/src/NHibernate/Hql/Ast/ANTLR/Tree/AggregateNode.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using Antlr.Runtime;
+using NHibernate.Dialect.Function;
 using NHibernate.Type;
 using NHibernate.Hql.Ast.ANTLR.Util;
 
@@ -19,6 +20,19 @@ public AggregateNode(IToken token)
 		{
 		}
 
+		public string FunctionName
+		{
+			get
+			{
+				if (SessionFactoryHelper.FindSQLFunction(Text) is ISQLFunctionExtended sqlFunction)
+				{
+					return sqlFunction.FunctionName;
+				}
+
+				return Text;
+			}
+		}
+
 		public override IType DataType
 		{
 			get
@@ -31,6 +45,7 @@ public override IType DataType
 				base.DataType = value;
 			}
 		}
+		
 		public override void SetScalarColumnText(int i)
 		{
 			ColumnHelper.GenerateSingleScalarColumn(ASTFactory, this, i);
diff --git a/src/NHibernate/Hql/Ast/ANTLR/Tree/CountNode.cs b/src/NHibernate/Hql/Ast/ANTLR/Tree/CountNode.cs
@@ -1,4 +1,5 @@
 ﻿using Antlr.Runtime;
+using NHibernate.Dialect.Function;
 using NHibernate.Hql.Ast.ANTLR.Util;
 using NHibernate.Type;
 
@@ -9,7 +10,7 @@ namespace NHibernate.Hql.Ast.ANTLR.Tree
 	/// Author: josh
 	/// Ported by: Steve Strong
 	/// </summary>
-	class CountNode : AbstractSelectExpression, ISelectExpression
+	class CountNode : AggregateNode, ISelectExpression
 	{
 		public CountNode(IToken token) : base(token)
 		{
@@ -26,9 +27,5 @@ public override IType DataType
 				base.DataType = value;
 			}
 		}
-		public override void SetScalarColumnText(int i)
-		{
-			ColumnHelper.GenerateSingleScalarColumn(ASTFactory, this, i);
-		}
 	}
 }
diff --git a/src/NHibernate/Hql/Ast/HqlTreeBuilder.cs b/src/NHibernate/Hql/Ast/HqlTreeBuilder.cs
@@ -307,6 +307,11 @@ public HqlCount Count(HqlExpression child)
 			return new HqlCount(_factory, child);
 		}
 
+		public HqlCountBig CountBig(HqlExpression child)
+		{
+			return new HqlCountBig(_factory, child);
+		}
+
 		public HqlRowStar RowStar()
 		{
 			return new HqlRowStar(_factory);
diff --git a/src/NHibernate/Hql/Ast/HqlTreeNode.cs b/src/NHibernate/Hql/Ast/HqlTreeNode.cs
@@ -697,6 +697,19 @@ public HqlCount(IASTFactory factory, HqlExpression child)
 		}
 	}
 
+	public class HqlCountBig : HqlExpression
+	{
+		public HqlCountBig(IASTFactory factory)
+			: base(HqlSqlWalker.COUNT, "count_big", factory)
+		{
+		}
+
+		public HqlCountBig(IASTFactory factory, HqlExpression child)
+			: base(HqlSqlWalker.COUNT, "count_big", factory, child)
+		{
+		}
+	}
+
 	public class HqlAs : HqlExpression
 	{
 		public HqlAs(IASTFactory factory, HqlExpression expression, System.Type type)
diff --git a/src/NHibernate/Linq/Visitors/HqlGeneratorExpressionVisitor.cs b/src/NHibernate/Linq/Visitors/HqlGeneratorExpressionVisitor.cs
diff --git a/src/NHibernate/Util/ExpressionsHelper.cs b/src/NHibernate/Util/ExpressionsHelper.cs

Original file line number	Diff line number	Diff line change
`@@ -55,6 +55,7 @@ public abstract partial class Dialect`
`55`	`55`	`static Dialect()`
`56`	`56`	`{`
`57`	`57`	`StandardAggregateFunctions["count"] = new CountQueryFunctionInfo();`
	`58`	`+ StandardAggregateFunctions["count_big"] = new CountQueryFunctionInfo();`
`58`	`59`	`StandardAggregateFunctions["avg"] = new AvgQueryFunctionInfo();`
`59`	`60`	`StandardAggregateFunctions["max"] = new ClassicAggregateFunction("max", false);`
`60`	`61`	`StandardAggregateFunctions["min"] = new ClassicAggregateFunction("min", false);`
Original file line number	Diff line number	Diff line change
`@@ -286,7 +286,8 @@ protected virtual void RegisterKeywords()`
`286`	`286`
`287`	`287`	`protected virtual void RegisterFunctions()`
`288`	`288`	`{`
`289`		`- RegisterFunction("count", new CountBigQueryFunction());`
	`289`	`+ RegisterFunction("count", new CountQueryFunction());`
	`290`	`+ RegisterFunction("count_big", new CountBigQueryFunction());`
`290`	`291`
`291`	`292`	`RegisterFunction("abs", new StandardSQLFunction("abs"));`
`292`	`293`	`RegisterFunction("absval", new StandardSQLFunction("absval"));`
`@@ -704,11 +705,15 @@ protected virtual string GetSelectExistingObject(string catalog, string schema,`
`704`	`705`	`[Serializable]`
`705`	`706`	`protected class CountBigQueryFunction : ClassicAggregateFunction`
`706`	`707`	`{`
`707`		`- public CountBigQueryFunction() : base("count_big", true) { }`
	`708`	`+ public CountBigQueryFunction() : base("count_big", true, NHibernateUtil.Int64) { }`
	`709`	`+ }`
`708`	`710`
`709`		`- public override IType ReturnType(IType columnType, IMapping mapping)`
	`711`	`+ [Serializable]`
	`712`	`+ private class CountQueryFunction : CountQueryFunctionInfo`
	`713`	`+ {`
	`714`	`+ public override IType GetEffectiveReturnType(IEnumerable<IType> argumentTypes, IMapping mapping, bool throwOnError)`
`710`	`715`	`{`
`711`		`- return NHibernateUtil.Int64;`
	`716`	`+ return NHibernateUtil.Int32;`
`712`	`717`	`}`
`713`	`718`	`}`
`714`	`719`
Original file line number	Diff line number	Diff line change
`@@ -310,6 +310,12 @@ private void EndFunctionTemplate(IASTNode m)`
`310`	`310`	`}`
`311`	`311`	`}`
`312`	`312`
	`313`	`+ private void OutAggregateFunctionName(IASTNode m)`
	`314`	`+ {`
	`315`	`+ var aggregateNode = (AggregateNode) m;`
	`316`	`+ Out(aggregateNode.FunctionName);`
	`317`	`+ }`
	`318`	`+`
`313`	`319`	`private void CommaBetweenParameters(String comma)`
`314`	`320`	`{`
`315`	`321`	`writer.CommaBetweenParameters(comma);`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ selectExpr`
`150`	`150`	`;`
`151`	`151`
`152`	`152`	`count`
`153`		`- : ^(COUNT { Out("count("); } ( distinctOrAll ) ? countExpr { Out(")"); } )`
	`153`	`+ : ^(c=COUNT { OutAggregateFunctionName(c); Out("("); } ( distinctOrAll ) ? countExpr { Out(")"); } )`
`154`	`154`	`;`
`155`	`155`
`156`	`156`	`distinctOrAll`
`@@ -344,7 +344,7 @@ caseExpr`
`344`	`344`	`;`
`345`	`345`
`346`	`346`	`aggregate`
`347`		`- : ^(a=AGGREGATE { Out(a); Out("("); } expr { Out(")"); } )`
	`347`	`+ : ^(a=AGGREGATE { OutAggregateFunctionName(a); Out("("); } expr { Out(")"); } )`
`348`	`348`	`;`
`349`	`349`
`350`	`350`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using Antlr.Runtime;`
	`3`	`+using NHibernate.Dialect.Function;`
`3`	`4`	`using NHibernate.Type;`
`4`	`5`	`using NHibernate.Hql.Ast.ANTLR.Util;`
`5`	`6`
`@@ -19,6 +20,19 @@ public AggregateNode(IToken token)`
`19`	`20`	`{`
`20`	`21`	`}`
`21`	`22`
	`23`	`+ public string FunctionName`
	`24`	`+ {`
	`25`	`+ get`
	`26`	`+ {`
	`27`	`+ if (SessionFactoryHelper.FindSQLFunction(Text) is ISQLFunctionExtended sqlFunction)`
	`28`	`+ {`
	`29`	`+ return sqlFunction.FunctionName;`
	`30`	`+ }`
	`31`	`+`
	`32`	`+ return Text;`
	`33`	`+ }`
	`34`	`+ }`
	`35`	`+`
`22`	`36`	`public override IType DataType`
`23`	`37`	`{`
`24`	`38`	`get`
`@@ -31,6 +45,7 @@ public override IType DataType`
`31`	`45`	`base.DataType = value;`
`32`	`46`	`}`
`33`	`47`	`}`
	`48`	`+`
`34`	`49`	`public override void SetScalarColumnText(int i)`
`35`	`50`	`{`
`36`	`51`	`ColumnHelper.GenerateSingleScalarColumn(ASTFactory, this, i);`