Support evaluation of Guid.NewGuid() on db side

Part of #959

Author: fredericDelaporte

src/NHibernate.Test/Async/Linq/PreEvaluationTests.cs

@@ -324,6 +324,40 @@ public async Task CanSelectDateTimeOffsetUtcNowAsync()
 				Assert.Fail("The test should have thrown a QueryException, but has not thrown anything");
 		}
 
+		[Test]
+		public async Task CanQueryByNewGuidAsync()
+		{
+			if (!TestDialect.SupportsSqlType(SqlTypeFactory.Guid))
+				Assert.Ignore("Guid are not supported by the target database");
+
+			using (var spy = new SqlLogSpy())
+			{
+				var guid = Guid.NewGuid();
+				var x = await (db.Orders.CountAsync(o => guid != Guid.NewGuid()));
+
+				Assert.That(x, Is.GreaterThan(0));
+				AssertFunctionInSql("new_uuid", spy);
+			}
+		}
+
+		[Test]
+		public async Task CanSelectNewGuidAsync()
+		{
+			if (!TestDialect.SupportsSqlType(SqlTypeFactory.Guid))
+				Assert.Ignore("Guid are not supported by the target database");
+
+			using (var spy = new SqlLogSpy())
+			{
+				var x =
+					await (db
+						.Orders.Select(o => new { id = o.OrderId, g = Guid.NewGuid() })
+						.OrderBy(o => o.id).Take(1).ToListAsync());
+
+				Assert.That(x, Has.Count.GreaterThan(0));
+				AssertFunctionInSql("new_uuid", spy);
+			}
+		}
+
 		private void AssertFunctionInSql(string functionName, SqlLogSpy spy)
 		{
 			if (!IsFunctionSupported(functionName))

src/NHibernate.Test/Linq/PreEvaluationTests.cs

@@ -312,6 +312,40 @@ public void CanSelectDateTimeOffsetUtcNow()
 				Assert.Fail("The test should have thrown a QueryException, but has not thrown anything");
 		}
 
+		[Test]
+		public void CanQueryByNewGuid()
+		{
+			if (!TestDialect.SupportsSqlType(SqlTypeFactory.Guid))
+				Assert.Ignore("Guid are not supported by the target database");
+
+			using (var spy = new SqlLogSpy())
+			{
+				var guid = Guid.NewGuid();
+				var x = db.Orders.Count(o => guid != Guid.NewGuid());
+
+				Assert.That(x, Is.GreaterThan(0));
+				AssertFunctionInSql("new_uuid", spy);
+			}
+		}
+
+		[Test]
+		public void CanSelectNewGuid()
+		{
+			if (!TestDialect.SupportsSqlType(SqlTypeFactory.Guid))
+				Assert.Ignore("Guid are not supported by the target database");
+
+			using (var spy = new SqlLogSpy())
+			{
+				var x =
+					db
+						.Orders.Select(o => new { id = o.OrderId, g = Guid.NewGuid() })
+						.OrderBy(o => o.id).Take(1).ToList();
+
+				Assert.That(x, Has.Count.GreaterThan(0));
+				AssertFunctionInSql("new_uuid", spy);
+			}
+		}
+
 		private void AssertFunctionInSql(string functionName, SqlLogSpy spy)
 		{
 			if (!IsFunctionSupported(functionName))

src/NHibernate/Dialect/FirebirdDialect.cs

@@ -423,6 +423,7 @@ private void OverrideStandardHQLFunctions()
 			RegisterFunction("strguid", new StandardSQLFunction("uuid_to_char", NHibernateUtil.String));
 			RegisterFunction("sysdate", new CastedFunction("today", NHibernateUtil.Date));
 			RegisterFunction("date", new SQLFunctionTemplate(NHibernateUtil.Date, "cast(?1 as date)"));
+			RegisterFunction("new_uuid", new NoArgSQLFunction("gen_uuid", NHibernateUtil.Guid));
 			// Bitwise operations
 			RegisterFunction("band", new Function.BitwiseFunctionOperation("bin_and"));
 			RegisterFunction("bor", new Function.BitwiseFunctionOperation("bin_or"));

src/NHibernate/Dialect/HanaDialectBase.cs

@@ -395,6 +395,7 @@ protected virtual void RegisterNHibernateFunctions()
 			RegisterFunction("iif", new SQLFunctionTemplate(null, "case when ?1 then ?2 else ?3 end"));
 			RegisterFunction("sysdate", new NoArgSQLFunction("current_timestamp", NHibernateUtil.DateTime, false));
 			RegisterFunction("truncate", new SQLFunctionTemplateWithRequiredParameters(null, "floor(?1 * power(10, ?2)) / power(10, ?2)", new object[] { null, "0" }));
+			RegisterFunction("new_uuid", new NoArgSQLFunction("sysuuid", NHibernateUtil.Guid, false));
 		}
 
 		protected virtual void RegisterHANAFunctions()

src/NHibernate/Dialect/MsSql2000Dialect.cs

@@ -359,6 +359,8 @@ protected virtual void RegisterFunctions()
 
 			RegisterFunction("bit_length", new SQLFunctionTemplate(NHibernateUtil.Int32, "datalength(?1) * 8"));
 			RegisterFunction("extract", new SQLFunctionTemplate(NHibernateUtil.Int32, "datepart(?1, ?3)"));
+
+			RegisterFunction("new_uuid", new NoArgSQLFunction("newid", NHibernateUtil.Guid));
 		}
 
 		protected virtual void RegisterGuidTypeMapping()

src/NHibernate/Dialect/MsSqlCeDialect.cs

@@ -200,6 +200,8 @@ protected virtual void RegisterFunctions()
 
 			RegisterFunction("bit_length", new SQLFunctionTemplate(NHibernateUtil.Int32, "datalength(?1) * 8"));
 			RegisterFunction("extract", new SQLFunctionTemplate(NHibernateUtil.Int32, "datepart(?1, ?3)"));
+
+			RegisterFunction("new_uuid", new NoArgSQLFunction("newid", NHibernateUtil.Guid));
 		}
 
 		protected virtual void RegisterDefaultProperties()

src/NHibernate/Dialect/MySQL5Dialect.cs

@@ -12,8 +12,14 @@ public MySQL5Dialect()
 			// My SQL supports precision up to 65, but .Net is limited to 28-29.
 			RegisterColumnType(DbType.Decimal, 29, "DECIMAL($p, $s)");
 			RegisterColumnType(DbType.Guid, "BINARY(16)");
+		}
+
+		protected override void RegisterFunctions()
+		{
+			base.RegisterFunctions();
 
 			RegisterFunction("strguid", new SQLFunctionTemplate(NHibernateUtil.String, "concat(hex(reverse(substr(?1, 1, 4))), '-', hex(reverse(substring(?1, 5, 2))), '-', hex(reverse(substr(?1, 7, 2))), '-', hex(substr(?1, 9, 2)), '-', hex(substr(?1, 11)))"));
+			RegisterFunction("new_uuid", new NoArgSQLFunction("uuid", NHibernateUtil.Guid));
 		}
 
 		protected override void RegisterCastTypes() 

src/NHibernate/Dialect/Oracle8iDialect.cs

@@ -310,6 +310,8 @@ protected virtual void RegisterFunctions()
 			RegisterFunction("bor", new SQLFunctionTemplate(null, "?1 + ?2 - BITAND(?1, ?2)"));
 			RegisterFunction("bxor", new SQLFunctionTemplate(null, "?1 + ?2 - BITAND(?1, ?2) * 2"));
 			RegisterFunction("bnot", new SQLFunctionTemplate(null, "(-1 - ?1)"));
+
+			RegisterFunction("new_uuid", new NoArgSQLFunction("sys_guid", NHibernateUtil.Guid));
 		}
 
 		protected internal virtual void RegisterDefaultProperties()

src/NHibernate/Dialect/PostgreSQLDialect.cs

@@ -98,6 +98,10 @@ public PostgreSQLDialect()
 
 			RegisterFunction("strguid", new SQLFunctionTemplate(NHibernateUtil.String, "?1::TEXT"));
 
+			// The uuid_generate_v4 is not native and must be installed, but SelectGUIDString property already uses it,
+			// and NHibernate.TestDatabaseSetup does install it.
+			RegisterFunction("new_uuid", new NoArgSQLFunction("uuid_generate_v4", NHibernateUtil.Guid));
+
 			RegisterKeywords();
 		}
 

src/NHibernate/Dialect/SQLiteDialect.cs

@@ -54,6 +54,8 @@ protected virtual void RegisterColumnTypes()
 			RegisterColumnType(DbType.DateTime, "DATETIME");
 			RegisterColumnType(DbType.Time, "TIME");
 			RegisterColumnType(DbType.Boolean, "BOOL");
+			// UNIQUEIDENTIFIER is not a SQLite type, but SQLite does not care much, see
+			// https://www.sqlite.org/datatype3.html
 			RegisterColumnType(DbType.Guid, "UNIQUEIDENTIFIER");
 		}
 
@@ -101,6 +103,11 @@ protected virtual void RegisterFunctions()
 			RegisterFunction("transparentcast", new CastFunction());
 
 			RegisterFunction("strguid", new SQLFunctionTemplate(NHibernateUtil.String, "substr(hex(?1), 7, 2) || substr(hex(?1), 5, 2) || substr(hex(?1), 3, 2) || substr(hex(?1), 1, 2) || '-' || substr(hex(?1), 11, 2) || substr(hex(?1), 9, 2) || '-' || substr(hex(?1), 15, 2) || substr(hex(?1), 13, 2) || '-' || substr(hex(?1), 17, 4) || '-' || substr(hex(?1), 21) "));
+			// This does not generate a valid uuid, but SelectGUIDString property already uses this.
+			// See https://www.ietf.org/rfc/rfc4122.txt
+			// System.Guid does not seem to care about the uuid validity, but this may still cause
+			// other issues.
+			RegisterFunction("new_uuid", new SQLFunctionTemplate(NHibernateUtil.Guid, "randomblob(16)"));
 		}
 
 		#region private static readonly string[] DialectKeywords = { ... }

src/NHibernate/Dialect/SybaseASE15Dialect.cs

@@ -56,6 +56,9 @@ public SybaseASE15Dialect()
 			RegisterColumnType(DbType.Date, "date");
 			RegisterColumnType(DbType.Binary, 8000, "varbinary($l)");
 			RegisterColumnType(DbType.Binary, "varbinary");
+			// newid default is to generate a 32 bytes character uuid (no-dashes), but it has an option for
+			// including dashes, then raising it to 36 bytes.
+			RegisterColumnType(DbType.Guid, "varchar(36)");
 
 			RegisterFunction("abs", new StandardSQLFunction("abs"));
 			RegisterFunction("acos", new StandardSQLFunction("acos", NHibernateUtil.Double));
@@ -113,6 +116,8 @@ public SybaseASE15Dialect()
 			RegisterFunction("year", new StandardSQLFunction("year", NHibernateUtil.Int32));
 
 			RegisterFunction("substring", new EmulatedLengthSubstringFunction());
+
+			RegisterFunction("new_uuid", new NoArgSQLFunction("newid", NHibernateUtil.Guid));
 		}
 
 		public override string AddColumnString

src/NHibernate/Dialect/SybaseSQLAnywhere10Dialect.cs

@@ -338,6 +338,7 @@ protected virtual void RegisterMiscellaneousFunctions()
 			RegisterFunction("isnull", new VarArgsSQLFunction("isnull(", ",", ")"));
 			RegisterFunction("lesser", new StandardSQLFunction("lesser"));
 			RegisterFunction("newid", new NoArgSQLFunction("newid", NHibernateUtil.String, true));
+			RegisterFunction("new_uuid", new NoArgSQLFunction("newid", NHibernateUtil.Guid));
 			RegisterFunction("nullif", new StandardSQLFunction("nullif"));
 			RegisterFunction("number", new NoArgSQLFunction("number", NHibernateUtil.Int32));
 			RegisterFunction("plan", new VarArgsSQLFunction(NHibernateUtil.String, "plan(", ",", ")"));

src/NHibernate/Linq/Functions/DefaultLinqToHqlGeneratorsRegistry.cs

@@ -58,6 +58,8 @@ public DefaultLinqToHqlGeneratorsRegistry()
 			this.Merge(new DateTimePropertiesHqlGenerator());
 			this.Merge(new DateTimeNowHqlGenerator());
 
+			this.Merge(new NewGuidHqlGenerator());
+
 			this.Merge(new DecimalAddGenerator());
 			this.Merge(new DecimalDivideGenerator());
 			this.Merge(new DecimalMultiplyGenerator());

src/NHibernate/Linq/Functions/IAllowPreEvaluationHqlGenerator.cs

@@ -7,12 +7,12 @@ namespace NHibernate.Linq.Functions
 	public interface IAllowPreEvaluationHqlGenerator
 	{
 		/// <summary>
-		/// Should pre-evaluation be allowed for this property?
+		/// Should pre-evaluation be allowed for this property or method?
 		/// </summary>
-		/// <param name="member">The property.</param>
+		/// <param name="member">The property or method.</param>
 		/// <param name="factory">The session factory.</param>
 		/// <returns>
-		/// <see langword="true" /> if the property should be evaluated before running the query whenever possible,
+		/// <see langword="true" /> if the property or method should be evaluated before running the query whenever possible,
 		/// <see langword="false" /> if it must always be translated to the equivalent HQL call.
 		/// </returns>
 		/// <remarks>Implementors should return <see langword="true" /> by default. Returning <see langword="false" />

src/NHibernate/Linq/Functions/IHqlGeneratorForMethod.cs

@@ -2,14 +2,47 @@
 using System.Collections.ObjectModel;
 using System.Linq.Expressions;
 using System.Reflection;
+using NHibernate.Engine;
 using NHibernate.Hql.Ast;
 using NHibernate.Linq.Visitors;
 
 namespace NHibernate.Linq.Functions
 {
-    public interface IHqlGeneratorForMethod
-    {
-        IEnumerable<MethodInfo> SupportedMethods { get; }
-        HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor);
-    }
-}
+	public interface IHqlGeneratorForMethod
+	{
+		IEnumerable<MethodInfo> SupportedMethods { get; }
+
+		HqlTreeNode BuildHql(
+			MethodInfo method,
+			Expression targetObject,
+			ReadOnlyCollection<Expression> arguments,
+			HqlTreeBuilder treeBuilder,
+			IHqlExpressionVisitor visitor);
+	}
+
+	// 6.0 TODO: merge into IHqlGeneratorForMethod
+	public static class HqlGeneratorForMethodExtensions
+	{
+		/// <summary>
+		/// Should pre-evaluation be allowed for this method?
+		/// </summary>
+		/// <param name="generator">The method's HQL generator.</param>
+		/// <param name="member">The method.</param>
+		/// <param name="factory">The session factory.</param>
+		/// <returns>
+		/// <see langword="true" /> if the method should be evaluated before running the query whenever possible,
+		/// <see langword="false" /> if it must always be translated to the equivalent HQL call.
+		/// </returns>
+		public static bool AllowPreEvaluation(
+			this IHqlGeneratorForMethod generator,
+			MemberInfo member,
+			ISessionFactoryImplementor factory)
+		{
+			if (generator is IAllowPreEvaluationHqlGenerator allowPreEvalGenerator)
+				return allowPreEvalGenerator.AllowPreEvaluation(member, factory);
+
+			// By default, everything should be pre-evaluated whenever possible.
+			return true;
+		}
+	}
+}

src/NHibernate/Linq/Functions/NewGuidHqlGenerator.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Linq.Expressions;
+using System.Reflection;
+using NHibernate.Engine;
+using NHibernate.Hql.Ast;
+using NHibernate.Linq.Visitors;
+using NHibernate.Util;
+
+namespace NHibernate.Linq.Functions
+{
+	public class NewGuidHqlGenerator : BaseHqlGeneratorForMethod, IAllowPreEvaluationHqlGenerator
+	{
+		public NewGuidHqlGenerator()
+		{
+			SupportedMethods = new[]
+			{
+				ReflectHelper.GetMethod(() => Guid.NewGuid())
+			};
+		}
+
+		public override HqlTreeNode BuildHql(
+			MethodInfo method,
+			Expression targetObject,
+			ReadOnlyCollection<Expression> arguments,
+			HqlTreeBuilder treeBuilder,
+			IHqlExpressionVisitor visitor)
+		{
+			return treeBuilder.MethodCall("new_uuid");
+		}
+
+		public bool AllowPreEvaluation(MemberInfo member, ISessionFactoryImplementor factory)
+		{
+			// When not supported, allow pre-evaluation on client side as a fallback.
+			return !factory.Dialect.Functions.ContainsKey("new_uuid");
+		}
+	}
+}

src/NHibernate/Linq/Visitors/NhPartialEvaluatingExpressionVisitor.cs

@@ -87,8 +87,14 @@ public override bool IsEvaluatableMethodCall(MethodCallExpression node)
 			var attributes = node.Method
 				.GetCustomAttributes(typeof(LinqExtensionMethodAttributeBase), false)
 				.Cast<LinqExtensionMethodAttributeBase>().ToArray();
-			return attributes.Length == 0 ||
-				attributes.Any(a => a.PreEvaluation == LinqExtensionPreEvaluation.AllowPreEvaluation);
+			if (attributes.Length > 0)
+				return attributes.Any(a => a.PreEvaluation == LinqExtensionPreEvaluation.AllowPreEvaluation);
+
+			if (_sessionFactory == null || _sessionFactory.Settings.LinqToHqlLegacyPreEvaluation ||
+				!_sessionFactory.Settings.LinqToHqlGeneratorsRegistry.TryGetGenerator(node.Method, out var generator))
+				return true;
+
+			return generator.AllowPreEvaluation(node.Method, _sessionFactory);
 		}
 	}
 }