Add EF.Functions.IsNumeric (#23232)

Co-authored-by: HuyLuong <[email protected]>

Resolves #23114

Author: RaymondHuy

src/EFCore.SqlServer/Extensions/SqlServerDbFunctionsExtensions.cs

@@ -1075,5 +1075,17 @@ public static TimeSpan TimeFromParts(
             [CanBeNull] this DbFunctions _,
             Guid? arg)
             => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(DataLength)));
+
+        /// <summary>
+        ///     Validate if the given string is a valid numeric.
+        ///     Corresponds to the SQL Server's ISNUMERIC(expression).
+        /// </summary>
+        /// <param name="_">The DbFunctions instance.</param>
+        /// <param name="expression">Expression to validate</param>
+        /// <returns>true for valid numeric and false otherwise.</returns>
+        public static bool IsNumeric(
+            [CanBeNull] this DbFunctions _,
+            [NotNull] string expression)
+            => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(IsNumeric)));
     }
 }

src/EFCore.SqlServer/Query/Internal/SqlServerIsNumericFunctionTranslator.cs

@@ -0,0 +1,67 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.EntityFrameworkCore.Query;
+using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
+using Microsoft.EntityFrameworkCore.Utilities;
+
+#nullable enable
+
+namespace Microsoft.EntityFrameworkCore.SqlServer.Query.Internal
+{
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public class SqlServerIsNumericFunctionTranslator : IMethodCallTranslator
+    {
+        private readonly ISqlExpressionFactory _sqlExpressionFactory;
+
+        private static readonly MethodInfo _methodInfo = typeof(SqlServerDbFunctionsExtensions)
+            .GetRequiredRuntimeMethod(nameof(SqlServerDbFunctionsExtensions.IsNumeric), new[] { typeof(DbFunctions), typeof(string) });
+
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     any release. You should only use it directly in your code with extreme caution and knowing that
+        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+        /// </summary>
+        public SqlServerIsNumericFunctionTranslator([NotNull] ISqlExpressionFactory sqlExpressionFactory)
+            => _sqlExpressionFactory = sqlExpressionFactory;
+
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     any release. You should only use it directly in your code with extreme caution and knowing that
+        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+        /// </summary>
+        public virtual SqlExpression? Translate(
+            SqlExpression? instance,
+            MethodInfo method,
+            IReadOnlyList<SqlExpression> arguments,
+            IDiagnosticsLogger<DbLoggerCategory.Query> logger)
+        {
+            Check.NotNull(method, nameof(method));
+            Check.NotNull(arguments, nameof(arguments));
+            Check.NotNull(logger, nameof(logger));
+
+            return _methodInfo.Equals(method)
+                ? _sqlExpressionFactory.Equal(
+                     _sqlExpressionFactory.Function(
+                        "ISNUMERIC",
+                        new[] { arguments[1] },
+                        nullable: false,
+                        argumentsPropagateNullability: new[] { false },
+                        typeof(int)),
+                     _sqlExpressionFactory.Constant(1))
+                : null;
+        }
+    }
+}

src/EFCore.SqlServer/Query/Internal/SqlServerMethodCallTranslatorProvider.cs

@@ -38,6 +38,7 @@ public SqlServerMethodCallTranslatorProvider([NotNull] RelationalMethodCallTrans
                     new SqlServerFromPartsFunctionTranslator(sqlExpressionFactory, typeMappingSource),
                     new SqlServerFullTextSearchFunctionsTranslator(sqlExpressionFactory),
                     new SqlServerIsDateFunctionTranslator(sqlExpressionFactory),
+                    new SqlServerIsNumericFunctionTranslator(sqlExpressionFactory),
                     new SqlServerMathTranslator(sqlExpressionFactory),
                     new SqlServerNewGuidTranslator(sqlExpressionFactory),
                     new SqlServerObjectToStringTranslator(sqlExpressionFactory),

test/EFCore.SqlServer.FunctionalTests/Query/NorthwindDbFunctionsQuerySqlServerTest.cs

@@ -742,6 +742,73 @@ public void IsDate_should_throw_on_client_eval()
                 exIsDate.Message);
         }
 
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual async Task IsNumeric_not_valid(bool async)
+        {
+            await AssertQueryScalar(
+                async,
+                ss => ss.Set<Order>()
+                    .Where(o => !EF.Functions.IsNumeric(o.OrderDate.Value.ToString()))
+                    .Select(o => EF.Functions.IsNumeric(o.OrderDate.Value.ToString())),
+                ss => ss.Set<Order>().Select(c => false));
+
+            AssertSql(
+                @"SELECT CASE
+    WHEN ISNUMERIC(CONVERT(varchar(100), [o].[OrderDate])) = 1 THEN CAST(1 AS bit)
+    ELSE CAST(0 AS bit)
+END
+FROM [Orders] AS [o]
+WHERE ISNUMERIC(CONVERT(varchar(100), [o].[OrderDate])) <> 1");
+        }
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual async Task IsNummeric_valid(bool async)
+        {
+            await AssertQueryScalar(
+                async,
+                ss => ss.Set<OrderDetail>()
+                    .Where(o => EF.Functions.IsNumeric(o.UnitPrice.ToString()))
+                    .Select(o => EF.Functions.IsNumeric(o.UnitPrice.ToString())),
+                ss => ss.Set<OrderDetail>().Select(o => true));
+
+            AssertSql(
+                @"SELECT CASE
+    WHEN ISNUMERIC(CONVERT(varchar(100), [o].[UnitPrice])) = 1 THEN CAST(1 AS bit)
+    ELSE CAST(0 AS bit)
+END
+FROM [Order Details] AS [o]
+WHERE ISNUMERIC(CONVERT(varchar(100), [o].[UnitPrice])) = 1");
+        }
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual async Task IsNumeric_join_fields(bool async)
+        {
+            await AssertCount(
+                async,
+                ss => ss.Set<Order>(),
+                ss => ss.Set<Order>(),
+                c => EF.Functions.IsNumeric(c.CustomerID + c.OrderID),
+                c => false);
+
+            AssertSql(
+                @"SELECT COUNT(*)
+FROM [Orders] AS [o]
+WHERE ISNUMERIC(COALESCE([o].[CustomerID], N'') + CAST([o].[OrderID] AS nchar(5))) = 1");
+        }
+
+        [ConditionalFact]
+        public void IsNumeric_should_throw_on_client_eval()
+        {
+            var exIsDate = Assert.Throws<InvalidOperationException>(() => EF.Functions.IsNumeric("#ISNUMERIC#"));
+
+            Assert.Equal(
+                CoreStrings.FunctionOnClient(nameof(SqlServerDbFunctionsExtensions.IsNumeric)),
+                exIsDate.Message);
+        }
+
         [ConditionalTheory]
         [MemberData(nameof(IsAsyncData))]
         public virtual async Task DateTimeFromParts_column_compare(bool async)