Implement TransformJsonQueryToTable for MySQL JSON_TABLE support

Co-authored-by: renemadsen <76994+renemadsen@users.noreply.github.com>

Author: Copilot

src/EFCore.MySql/Query/Internal/MySqlQueryableMethodTranslatingExpressionVisitor.cs

@@ -2,6 +2,8 @@
 // Licensed under the MIT. See LICENSE in the project root for license information.
 
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Linq.Expressions;
@@ -210,10 +212,127 @@ protected override ShapedQueryExpression TranslateElementAtOrDefault(
         return base.TranslateElementAtOrDefault(source, index, returnDefault);
     }
 
-    // TODO: Implement for EF Core 7 JSON support.
     protected override ShapedQueryExpression TransformJsonQueryToTable(JsonQueryExpression jsonQueryExpression)
     {
-        return base.TransformJsonQueryToTable(jsonQueryExpression);
+        // Calculate the table alias for the JSON_TABLE function based on the last named path segment
+        // (or the JSON column name if there are none)
+        var lastNamedPathSegment = jsonQueryExpression.Path.LastOrDefault(ps => ps.PropertyName is not null);
+        var tableAlias = _sqlAliasManager.GenerateTableAlias(
+            lastNamedPathSegment.PropertyName ?? jsonQueryExpression.JsonColumn.Name);
+
+        // We now add all of the projected entity's properties and navigations into the JSON_TABLE's COLUMNS clause
+        var columnInfos = new List<MySqlJsonTableExpression.ColumnInfo>();
+
+        // We're only interested in properties which actually exist in the JSON, filter out uninteresting shadow keys
+        foreach (var property in jsonQueryExpression.StructuralType.GetPropertiesInHierarchy())
+        {
+            if (property.GetJsonPropertyName() is string jsonPropertyName)
+            {
+                var typeMapping = property.GetRelationalTypeMapping();
+                
+                columnInfos.Add(
+                    new MySqlJsonTableExpression.ColumnInfo(
+                        Name: jsonPropertyName,
+                        TypeMapping: typeMapping,
+                        // Build path for this property: $[0]
+                        Path: [new PathSegment(_sqlExpressionFactory.Constant(0, _typeMappingSource.FindMapping(typeof(int))))],
+                        AsJson: false));
+            }
+        }
+
+        // Add navigations to owned entities mapped to JSON
+        switch (jsonQueryExpression.StructuralType)
+        {
+            case IEntityType entityType:
+                foreach (var navigation in entityType.GetNavigationsInHierarchy()
+                    .Where(n => n.ForeignKey.IsOwnership
+                        && n.TargetEntityType.IsMappedToJson()
+                        && n.ForeignKey.PrincipalToDependent == n))
+                {
+                    var jsonNavigationName = navigation.TargetEntityType.GetJsonPropertyName();
+                    Check.DebugAssert(jsonNavigationName is not null, $"No JSON property name for navigation {navigation.Name}");
+
+                    columnInfos.Add(
+                        new MySqlJsonTableExpression.ColumnInfo(
+                            Name: jsonNavigationName,
+                            TypeMapping: jsonQueryExpression.JsonColumn.TypeMapping!,
+                            Path: [new PathSegment(_sqlExpressionFactory.Constant(0, _typeMappingSource.FindMapping(typeof(int))))],
+                            AsJson: true));
+                }
+                break;
+
+            case IComplexType complexType:
+                foreach (var complexProperty in complexType.GetComplexProperties())
+                {
+                    var jsonPropertyName = complexProperty.ComplexType.GetJsonPropertyName();
+                    Check.DebugAssert(jsonPropertyName is not null, $"No JSON property name for complex property {complexProperty.Name}");
+
+                    columnInfos.Add(
+                        new MySqlJsonTableExpression.ColumnInfo(
+                            Name: jsonPropertyName,
+                            TypeMapping: jsonQueryExpression.JsonColumn.TypeMapping!,
+                            Path: [new PathSegment(_sqlExpressionFactory.Constant(0, _typeMappingSource.FindMapping(typeof(int))))],
+                            AsJson: true));
+                }
+                break;
+
+            default:
+                throw new UnreachableException();
+        }
+
+        // MySQL JSON_TABLE requires the nested JSON document - it does not accept a path within a containing JSON document
+        // in the same way as SQL Server OPENJSON. So we wrap JSON_TABLE around a JsonScalarExpression which will extract
+        // the nested document.
+        var jsonScalarExpression = new JsonScalarExpression(
+            jsonQueryExpression.JsonColumn,
+            jsonQueryExpression.Path,
+            typeof(string),
+            jsonQueryExpression.JsonColumn.TypeMapping,
+            jsonQueryExpression.IsNullable);
+
+        // Construct the JSON_TABLE expression with the JsonScalarExpression
+        var jsonTableExpression = new MySqlJsonTableExpression(
+            tableAlias,
+            jsonScalarExpression,
+            [new PathSegment(_sqlExpressionFactory.Constant("*", RelationalTypeMapping.NullMapping))],
+            [.. columnInfos]);
+
+        // Create the key column for ordering (JSON_TABLE returns a 'key' column for array elements)
+        var keyColumnTypeMapping = _typeMappingSource.FindMapping(typeof(uint))!;
+
+#pragma warning disable EF1001 // Internal EF Core API usage.
+        var selectExpression = new SelectExpression(
+            [jsonTableExpression],
+            new ColumnExpression(
+                "key",
+                tableAlias,
+                typeof(uint),
+                keyColumnTypeMapping,
+                nullable: false),
+            identifier: [(new ColumnExpression("key", tableAlias, typeof(uint), keyColumnTypeMapping, nullable: false), keyColumnTypeMapping.Comparer)],
+            _sqlAliasManager);
+#pragma warning restore EF1001 // Internal EF Core API usage.
+
+        // Add ordering by the key column to maintain array order
+        selectExpression.AppendOrdering(
+            new OrderingExpression(
+                selectExpression.CreateColumnExpression(
+                    jsonTableExpression,
+                    "key",
+                    typeof(uint),
+                    typeMapping: keyColumnTypeMapping,
+                    columnNullable: false),
+                ascending: true));
+
+        return new ShapedQueryExpression(
+            selectExpression,
+            new RelationalStructuralTypeShaperExpression(
+                jsonQueryExpression.StructuralType,
+                new ProjectionBindingExpression(
+                    selectExpression,
+                    new ProjectionMember(),
+                    typeof(ValueBuffer)),
+                false));
     }
 
     protected override ShapedQueryExpression TranslatePrimitiveCollection(SqlExpression sqlExpression, IProperty property, string tableAlias)