Implement EF.Functions.JsonExists translation for SQL Server (#31136)

src/EFCore.Relational/Extensions/RelationalDbFunctionsExtensions.cs

@@ -56,4 +56,17 @@ public static T Greatest<T>(
         this DbFunctions _,
         [NotParameterized] params T[] values)
         => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(Greatest)));
+
+    /// <summary>
+    ///     Returns a value indicating whether a given JSON path exists within the specified JSON.
+    ///     Usually corresponds to the <c>JSON_PATH_EXISTS</c> SQL function.
+    /// </summary>
+    /// <param name="_">The <see cref="DbFunctions" /> instance.</param>
+    /// <param name="json">The JSON value to check.</param>
+    /// <param name="path">The JSON path to look for.</param>
+    public static bool JsonExists(
+        this DbFunctions _,
+        object json,
+        [NotParameterized] string path)
+        => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(JsonExists)));
 }

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

@@ -38,6 +38,7 @@ public SqlServerMethodCallTranslatorProvider(
             new SqlServerFullTextSearchFunctionsTranslator(sqlExpressionFactory),
             new SqlServerIsDateFunctionTranslator(sqlExpressionFactory),
             new SqlServerIsNumericFunctionTranslator(sqlExpressionFactory),
+            new SqlServerJsonFunctionTranslator(sqlExpressionFactory),
             new SqlServerMathTranslator(sqlExpressionFactory),
             new SqlServerNewGuidTranslator(sqlExpressionFactory),
             new SqlServerObjectToStringTranslator(sqlExpressionFactory, typeMappingSource),

src/EFCore.SqlServer/Query/Internal/Translators/SqlServerJsonFunctionTranslator.cs

@@ -0,0 +1,57 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
+
+// ReSharper disable once CheckNamespace
+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 SqlServerJsonFunctionTranslator : IMethodCallTranslator
+{
+    private readonly ISqlExpressionFactory _sqlExpressionFactory;
+
+    private static readonly MethodInfo JsonExistsMethodInfo = typeof(RelationalDbFunctionsExtensions)
+        .GetRuntimeMethod(nameof(RelationalDbFunctionsExtensions.JsonExists), [typeof(DbFunctions), typeof(object), 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 SqlServerJsonFunctionTranslator(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)
+    {
+        if (JsonExistsMethodInfo.Equals(method))
+        {
+            return _sqlExpressionFactory.Equal(
+                _sqlExpressionFactory.Function(
+                    "JSON_PATH_EXISTS",
+                    [arguments[1], arguments[2]],
+                    nullable: true,
+                    argumentsPropagateNullability: [true, false],
+                    typeof(int)),
+                _sqlExpressionFactory.Constant(1));
+        }
+
+        return null;
+    }
+}

test/EFCore.Relational.Tests/RelationalDbFunctionsTest.cs

@@ -0,0 +1,34 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+// ReSharper disable ArgumentsStyleStringLiteral
+// ReSharper disable InconsistentNaming
+
+namespace Microsoft.EntityFrameworkCore;
+
+public class RelationalDbFunctionsTest
+{
+    [ConditionalFact]
+    public void Collate_on_client_throws()
+        => Assert.Equal(
+            CoreStrings.FunctionOnClient(nameof(RelationalDbFunctionsExtensions.Collate)),
+            Assert.Throws<InvalidOperationException>(() => EF.Functions.Collate("abc", "Latin1_General_CI_AS")).Message);
+
+    [ConditionalFact]
+    public void Least_on_client_throws()
+        => Assert.Equal(
+            CoreStrings.FunctionOnClient(nameof(RelationalDbFunctionsExtensions.Least)),
+            Assert.Throws<InvalidOperationException>(() => EF.Functions.Least(1, 2, 3)).Message);
+
+    [ConditionalFact]
+    public void Greatest_on_client_throws()
+        => Assert.Equal(
+            CoreStrings.FunctionOnClient(nameof(RelationalDbFunctionsExtensions.Greatest)),
+            Assert.Throws<InvalidOperationException>(() => EF.Functions.Greatest(1, 2, 3)).Message);
+
+    [ConditionalFact]
+    public void JsonExists_on_client_throws()
+        => Assert.Equal(
+            CoreStrings.FunctionOnClient(nameof(RelationalDbFunctionsExtensions.JsonExists)),
+            Assert.Throws<InvalidOperationException>(() => EF.Functions.JsonExists("{\"key\": 1}", "$.key")).Message);
+}

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

@@ -1348,6 +1348,30 @@ WHERE CAST(DATALENGTH(N'foo') AS int) = 3
         }
     }
 
+    [ConditionalFact]
+    public void JsonExists_client_eval_throws()
+    {
+        Assert.Throws<InvalidOperationException>(() => EF.Functions.JsonExists("{\"key\": 1}", "$.key"));
+    }
+
+    [ConditionalFact, SqlServerCondition(SqlServerCondition.SupportsFunctions2022)]
+    public async Task JsonExists_on_json_string_literal()
+    {
+        await using var context = CreateContext();
+        var result = await context.Customers
+            .Where(c => EF.Functions.JsonExists("{\"name\": \"test\"}", "$.name"))
+            .CountAsync();
+
+        Assert.Equal(91, result);
+
+        AssertSql(
+            """
+SELECT COUNT(*)
+FROM [Customers] AS [c]
+WHERE JSON_PATH_EXISTS(N'{"name": "test"}', N'$.name') = 1
+""");
+    }
+
     private void AssertSql(params string[] expected)
         => Fixture.TestSqlLoggerFactory.AssertBaseline(expected);
 }