Feature/translate json functions #29306

src/EFCore.SqlServer/Extensions/SqlServerDbFunctionsExtensions.cs

@@ -16,6 +16,44 @@ namespace Microsoft.EntityFrameworkCore;
 /// </remarks>
 public static class SqlServerDbFunctionsExtensions
 {
+    /// <summary>
+    ///     Extracts a scalar value from a JSON string. <paramref name="propertyReference" /> and <paramref name="path" />.
+    ///     Corresponds to SQL Server's <c>JSON_VALUE(@propertyReference, @path)</c>.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-database-functions">Database functions</see>, and
+    ///     <see href="https://aka.ms/efcore-docs-sqlserver">Accessing SQL Server and SQL Azure databases with EF Core</see>
+    ///     for more information and examples.
+    /// </remarks>
+    /// <param name="_">The <see cref="DbFunctions" /> instance.</param>
+    /// <param name="propertyReference">The property in table</param>
+    /// <param name="path">The json path.</param>
+    /// <returns>Value of path</returns>
+    public static string JsonValue(
+        this DbFunctions _,
+        object propertyReference,
+        string path)
+        => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(SqlServerDbFunctionsExtensions.JsonValue)));
+
+    /// <summary>
+    ///     Extracts an object or an array from a JSON string. <paramref name="propertyReference" /> and <paramref name="path" />.
+    ///     Corresponds to SQL Server's <c>JSON_VALUE(@propertyReference, @path)</c>.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-database-functions">Database functions</see>, and
+    ///     <see href="https://aka.ms/efcore-docs-sqlserver">Accessing SQL Server and SQL Azure databases with EF Core</see>
+    ///     for more information and examples.
+    /// </remarks>
+    /// <param name="_">The <see cref="DbFunctions" /> instance.</param>
+    /// <param name="propertyReference">The property in table</param>
+    /// <param name="path">The json path.</param>
+    /// <returns>Value of path</returns>
+    public static string JsonQuery(
+        this DbFunctions _,
+        object propertyReference,
+        string path)
+        => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(SqlServerDbFunctionsExtensions.JsonQuery)));
+
     /// <summary>
     ///     A DbFunction method stub that can be used in LINQ queries to target the SQL Server <c>FREETEXT</c> store function.
     /// </summary>

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

@@ -0,0 +1,79 @@
+// 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;
+
+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 SqlServerJsonFunctionsTranslator : IMethodCallTranslator
+{
+
+    private readonly Dictionary<MethodInfo, string> _methodInfoJsonFunctions
+        = new()
+        {
+            {
+                typeof(SqlServerDbFunctionsExtensions).GetRuntimeMethod(nameof(SqlServerDbFunctionsExtensions.JsonValue), new[] { typeof(DbFunctions), typeof(object), typeof(string) })!,
+                "JSON_VALUE"
+            },
+            {
+                typeof(SqlServerDbFunctionsExtensions).GetRuntimeMethod(nameof(SqlServerDbFunctionsExtensions.JsonQuery), new[] { typeof(DbFunctions), typeof(object), typeof(string) })!,
+                "JSON_QUERY"
+            },
+        };
+
+    private readonly ISqlExpressionFactory _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 SqlServerJsonFunctionsTranslator(
+        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 SqlExpression? Translate(
+        SqlExpression? instance,
+        MethodInfo method,
+        IReadOnlyList<SqlExpression> arguments,
+        IDiagnosticsLogger<DbLoggerCategory.Query> logger)
+    {
+        if (_methodInfoJsonFunctions.TryGetValue(method, out var function))
+        {
+            var propertyReference = arguments[1];
+
+            var typeMapping = propertyReference.TypeMapping;
+            var path = propertyReference.Type == arguments[2].Type
+                ? _sqlExpressionFactory.ApplyTypeMapping(arguments[2], typeMapping)
+                : _sqlExpressionFactory.ApplyDefaultTypeMapping(arguments[2]);
+
+            var functionArguments = new List<SqlExpression> { propertyReference, path };
+
+            return _sqlExpressionFactory.Function(
+                function,
+                functionArguments,
+                nullable: true,
+                // TODO: don't propagate for now
+                argumentsPropagateNullability: functionArguments.Select(_ => false).ToList(),
+                typeof(string));
+        }
+
+        return null;
+    }
+}

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

@@ -29,6 +29,7 @@ public SqlServerMethodCallTranslatorProvider(RelationalMethodCallTranslatorProvi
                 new SqlServerConvertTranslator(sqlExpressionFactory),
                 new SqlServerDataLengthFunctionTranslator(sqlExpressionFactory),
                 new SqlServerDateDiffFunctionsTranslator(sqlExpressionFactory),
+                new SqlServerJsonFunctionsTranslator(sqlExpressionFactory),
                 new SqlServerDateTimeMethodTranslator(sqlExpressionFactory, typeMappingSource),
                 new SqlServerFromPartsFunctionTranslator(sqlExpressionFactory, typeMappingSource),
                 new SqlServerFullTextSearchFunctionsTranslator(sqlExpressionFactory),

src/EFCore.Sqlite.Core/Extensions/SqliteDbFunctionsExtensions.cs

@@ -30,6 +30,23 @@ public static class SqliteDbFunctionsExtensions
     public static bool Glob(this DbFunctions _, string matchExpression, string pattern)
         => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(Glob)));
 
+
+    /// <summary>
+    ///     Maps to the SQLite <c>json_extract</c> function, which extracts and returns one or more values from well-formed JSON.
+    /// </summary>
+    /// <remarks>
+    ///     See <see href="https://aka.ms/efcore-docs-database-functions">Database functions</see>, and
+    ///     <see href="https://aka.ms/efcore-docs-sqlite">Accessing SQLite databases with EF Core</see> for more information and examples.
+    /// </remarks>
+    /// <param name="_">The <see cref="DbFunctions" /> instance.</param>
+    /// <param name="propertyReference">The column</param>
+    /// /// <param name="paths">The column</param>
+    /// <returns>A hexadecimal string.</returns>
+    public static string JsonExtract(this DbFunctions _,
+        object propertyReference,
+        string paths)
+        => throw new InvalidOperationException(CoreStrings.FunctionOnClient(nameof(JsonExtract)));
+
     /// <summary>
     ///     Maps to the SQLite <c>hex</c> function which returns a hexadecimal string representing the specified value.
     /// </summary>

src/EFCore.Sqlite.Core/Query/Internal/SqliteJsonFunctionsTranslator.cs

@@ -0,0 +1,76 @@
+// 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;
+
+namespace Microsoft.EntityFrameworkCore.Sqlite.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 SqliteJsonFunctionsTranslator : IMethodCallTranslator
+{
+
+    private readonly Dictionary<MethodInfo, string> _methodInfoJsonFunctions
+        = new()
+        {
+            {
+                typeof(SqliteDbFunctionsExtensions).GetRuntimeMethod(nameof(SqliteDbFunctionsExtensions.JsonExtract), new[] { typeof(DbFunctions), typeof(object), typeof(string) })!,
+                "json_extract"
+            }
+        };
+
+    private readonly ISqlExpressionFactory _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 SqliteJsonFunctionsTranslator(
+        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 SqlExpression? Translate(
+        SqlExpression? instance,
+        MethodInfo method,
+        IReadOnlyList<SqlExpression> arguments,
+        IDiagnosticsLogger<DbLoggerCategory.Query> logger)
+    {
+        if (_methodInfoJsonFunctions.TryGetValue(method, out var function))
+        {
+            var propertyReference = arguments[1];
+
+            var typeMapping = propertyReference.TypeMapping;
+
+            var path = propertyReference.Type == arguments[2].Type
+                        ? _sqlExpressionFactory.ApplyTypeMapping(arguments[2], typeMapping)
+                        : _sqlExpressionFactory.ApplyDefaultTypeMapping(arguments[2]);
+
+            var functionArguments = new List<SqlExpression> { propertyReference, path };
+
+            return _sqlExpressionFactory.Function(
+                function,
+                functionArguments,
+                nullable: true,
+                // TODO: don't propagate for now
+                argumentsPropagateNullability: functionArguments.Select(_ => false).ToList(),
+                typeof(string));
+        }
+
+        return null;
+    }
+}

src/EFCore.Sqlite.Core/Query/Internal/SqliteMethodCallTranslatorProvider.cs

@@ -29,6 +29,7 @@ public SqliteMethodCallTranslatorProvider(RelationalMethodCallTranslatorProvider
                 new SqliteCharMethodTranslator(sqlExpressionFactory),
                 new SqliteDateTimeAddTranslator(sqlExpressionFactory),
                 new SqliteGlobMethodTranslator(sqlExpressionFactory),
+                new SqliteJsonFunctionsTranslator(sqlExpressionFactory),
                 new SqliteHexMethodTranslator(sqlExpressionFactory),
                 new SqliteMathTranslator(sqlExpressionFactory),
                 new SqliteObjectToStringTranslator(sqlExpressionFactory),

test/EFCore.Relational.Specification.Tests/TestModels/JsonQuery/JsonEntityBasicString.cs

@@ -0,0 +1,11 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.EntityFrameworkCore.TestModels.JsonQuery;
+public class JsonEntityBasicString
+{
+    public int Id { get; set; }
+    public string Name { get; set; }
+
+    public string OwnedReferenceRoot { get; set; }
+}

test/EFCore.Relational.Specification.Tests/TestModels/JsonQuery/JsonQueryContext.cs

@@ -12,6 +12,8 @@ public JsonQueryContext(DbContextOptions options)
 
     public DbSet<EntityBasic> EntitiesBasic { get; set; }
     public DbSet<JsonEntityBasic> JsonEntitiesBasic { get; set; }
+    public DbSet<JsonEntityBasicString> JsonEntitiesBasicString { get; set; }
+
     public DbSet<JsonEntityBasicForReference> JsonEntitiesBasicForReference { get; set; }
     public DbSet<JsonEntityBasicForCollection> JsonEntitiesBasicForCollection { get; set; }
     public DbSet<JsonEntityCustomNaming> JsonEntitiesCustomNaming { get; set; }
@@ -22,6 +24,7 @@ public JsonQueryContext(DbContextOptions options)
     public static void Seed(JsonQueryContext context)
     {
         var jsonEntitiesBasic = JsonQueryData.CreateJsonEntitiesBasic();
+        var jsonEntitiesBasicStrings = JsonQueryData.CreateJsonEntitiesBasicString();
         var jsonEntitiesBasicForReference = JsonQueryData.CreateJsonEntitiesBasicForReference();
         var jsonEntitiesBasicForCollection = JsonQueryData.CreateJsonEntitiesBasicForCollection();
         JsonQueryData.WireUp(jsonEntitiesBasic, jsonEntitiesBasicForReference, jsonEntitiesBasicForCollection);
@@ -32,6 +35,7 @@ public static void Seed(JsonQueryContext context)
         var jsonEntitiesAllTypes = JsonQueryData.CreateJsonEntitiesAllTypes();
 
         context.JsonEntitiesBasic.AddRange(jsonEntitiesBasic);
+        context.JsonEntitiesBasicString.AddRange(jsonEntitiesBasicStrings);
         context.JsonEntitiesBasicForReference.AddRange(jsonEntitiesBasicForReference);
         context.JsonEntitiesBasicForCollection.AddRange(jsonEntitiesBasicForCollection);
         context.JsonEntitiesCustomNaming.AddRange(jsonEntitiesCustomNaming);

test/EFCore.Relational.Specification.Tests/TestModels/JsonQuery/JsonQueryData.cs

@@ -9,6 +9,7 @@ public JsonQueryData()
     {
         EntitiesBasic = new List<EntityBasic>();
         JsonEntitiesBasic = CreateJsonEntitiesBasic();
+        JsonEntitiesBasicStrings = CreateJsonEntitiesBasicString();
         JsonEntitiesBasicForReference = CreateJsonEntitiesBasicForReference();
         JsonEntitiesBasicForCollection = CreateJsonEntitiesBasicForCollection();
         WireUp(JsonEntitiesBasic, JsonEntitiesBasicForReference, JsonEntitiesBasicForCollection);
@@ -21,13 +22,25 @@ public JsonQueryData()
 
     public IReadOnlyList<EntityBasic> EntitiesBasic { get; }
     public IReadOnlyList<JsonEntityBasic> JsonEntitiesBasic { get; }
+    public IReadOnlyList<JsonEntityBasicString> JsonEntitiesBasicStrings { get; }
+
     public IReadOnlyList<JsonEntityBasicForReference> JsonEntitiesBasicForReference { get; }
     public IReadOnlyList<JsonEntityBasicForCollection> JsonEntitiesBasicForCollection { get; }
     public IReadOnlyList<JsonEntityCustomNaming> JsonEntitiesCustomNaming { get; set; }
     public IReadOnlyList<JsonEntitySingleOwned> JsonEntitiesSingleOwned { get; set; }
     public IReadOnlyList<JsonEntityInheritanceBase> JsonEntitiesInheritance { get; set; }
     public IReadOnlyList<JsonEntityAllTypes> JsonEntitiesAllTypes { get; set; }
 
+
+    public static IReadOnlyList<JsonEntityBasicString> CreateJsonEntitiesBasicString()
+    {
+        var entity = new JsonEntityBasicString();
+        entity.Name = "Testing SQL Json-functions.";
+        entity.OwnedReferenceRoot = "{\"Name\":\"e1_r\",\"Number\":10,\"OwnedCollectionBranch\":[{\"Date\":\"2101-01-01T00:00:00\",\"Enum\":\"Two\",\"Fraction\":10.1,\"NullableEnum\":\"One\",\"OwnedCollectionLeaf\":[{\"SomethingSomething\":\"e1_r_c1_c1\"},{\"SomethingSomething\":\"e1_r_c1_c2\"}],\"OwnedReferenceLeaf\":{\"SomethingSomething\":\"e1_r_c1_r\"}},{\"Date\":\"2102-01-01T00:00:00\",\"Enum\":\"Three\",\"Fraction\":10.2,\"NullableEnum\":\"Two\",\"OwnedCollectionLeaf\":[{\"SomethingSomething\":\"e1_r_c2_c1\"},{\"SomethingSomething\":\"e1_r_c2_c2\"}],\"OwnedReferenceLeaf\":{\"SomethingSomething\":\"e1_r_c2_r\"}}],\"OwnedReferenceBranch\":{\"Date\":\"2100-01-01T00:00:00\",\"Enum\":\"One\",\"Fraction\":10.0,\"NullableEnum\":null,\"OwnedCollectionLeaf\":[{\"SomethingSomething\":\"e1_r_r_c1\"},{\"SomethingSomething\":\"e1_r_r_c2\"}],\"OwnedReferenceLeaf\":{\"SomethingSomething\":\"e1_r_r_r\"}}}";
+
+        return new List<JsonEntityBasicString>() { entity };
+    }
+
     public static IReadOnlyList<JsonEntityBasic> CreateJsonEntitiesBasic()
     {
         //-------------------------------------------------------------------------------------------
@@ -776,6 +789,11 @@ public IQueryable<TEntity> Set<TEntity>()
             return (IQueryable<TEntity>)JsonEntitiesBasic.AsQueryable();
         }
 
+        if (typeof(TEntity) == typeof(JsonEntityBasicString))
+        {
+            return (IQueryable<TEntity>)JsonEntitiesBasicStrings.AsQueryable();
+        }
+
         if (typeof(TEntity) == typeof(JsonEntityCustomNaming))
         {
             return (IQueryable<TEntity>)JsonEntitiesCustomNaming.AsQueryable();