Fix: Use MySqlStructuralJsonTypeMapping like SQL Server

Created MySqlStructuralJsonTypeMapping (similar to SqlServerStructuralJsonTypeMapping) with:
- ClrType = JsonTypePlaceholder (not MemoryStream or string)
- GetDataReaderMethod() returns DbDataReader.GetString
- CustomizeDataReaderExpression() converts string→MemoryStream

This matches SQL Server's implementation and avoids SQL generation issues.
Using different type mappings with different ClrTypes was breaking SQL generation
because EF Core uses the type mapping during both SQL generation and data reading.

Removed ClrType-based conversion logic from MySqlJsonTypeMapping since it's now
only used for regular JSON columns mapped to string properties.

Researched dotnet/efcore SqlServer implementation for reference.

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

Author: Copilot

src/EFCore.MySql/Storage/Internal/MySqlJsonTypeMapping.cs

@@ -64,14 +64,6 @@ public abstract class MySqlJsonTypeMapping : MySqlStringTypeMapping, IMySqlCShar
         protected static readonly MethodInfo _getString
             = typeof(DbDataReader).GetRuntimeMethod(nameof(DbDataReader.GetString), new[] { typeof(int) });
 
-        // Cache reflection lookups for performance
-        protected static readonly PropertyInfo _utf8Property
-            = typeof(System.Text.Encoding).GetProperty(nameof(System.Text.Encoding.UTF8));
-        protected static readonly MethodInfo _getBytesMethod
-            = typeof(System.Text.Encoding).GetMethod(nameof(System.Text.Encoding.GetBytes), new[] { typeof(string) });
-        protected static readonly ConstructorInfo _memoryStreamCtor
-            = typeof(System.IO.MemoryStream).GetConstructor(new[] { typeof(byte[]) });
-
         public MySqlJsonTypeMapping(
             [NotNull] string storeType,
             [NotNull] Type clrType,
@@ -142,32 +134,12 @@ public override MethodInfo GetDataReaderMethod()
 
         /// <summary>
         /// Customizes the data reader expression for JSON types.
-        /// MySQL stores JSON as strings, but EF Core expects MemoryStream for complex JSON types.
-        /// We only convert when ClrType is MemoryStream (complex JSON types), not for regular JSON columns mapped to string.
+        /// This is only used for regular JSON columns mapped to string properties.
+        /// Complex JSON types use MySqlStructuralJsonTypeMapping instead.
         /// </summary>
         public override Expression CustomizeDataReaderExpression(Expression expression)
         {
-            // Only convert for complex JSON types (where ClrType is MemoryStream)
-            // For regular JSON columns mapped to string, don't convert
-            if (expression.Type == typeof(string) && ClrType == typeof(System.IO.MemoryStream))
-            {
-                // Validate that reflection lookups succeeded
-                if (_utf8Property == null || _getBytesMethod == null || _memoryStreamCtor == null)
-                {
-                    throw new InvalidOperationException(
-                        "Failed to find required reflection members for JSON type mapping. " +
-                        "This may indicate an incompatible version of the .NET runtime.");
-                }
-
-                // Convert string to MemoryStream: new MemoryStream(Encoding.UTF8.GetBytes(stringValue))
-                return Expression.New(
-                    _memoryStreamCtor,
-                    Expression.Call(
-                        Expression.Property(null, _utf8Property),
-                        _getBytesMethod,
-                        expression));
-            }
-
+            // For regular JSON columns, no conversion needed - just return the string
             return base.CustomizeDataReaderExpression(expression);
         }
 

src/EFCore.MySql/Storage/Internal/MySqlStructuralJsonTypeMapping.cs

@@ -0,0 +1,77 @@
+// Copyright (c) Pomelo Foundation. All rights reserved.
+// Licensed under the MIT. See LICENSE in the project root for license information.
+
+using System;
+using System.Data.Common;
+using System.IO;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Text;
+using Microsoft.EntityFrameworkCore.Storage;
+using MySqlConnector;
+
+namespace Pomelo.EntityFrameworkCore.MySql.Storage.Internal
+{
+    /// <summary>
+    /// Type mapping for complex JSON types (types mapped with .ToJson()).
+    /// This mapping handles the conversion from MySQL's string-based JSON to MemoryStream expected by EF Core.
+    /// </summary>
+    public class MySqlStructuralJsonTypeMapping : JsonTypeMapping
+    {
+        private static readonly MethodInfo _createUtf8StreamMethod
+            = typeof(MySqlStructuralJsonTypeMapping).GetMethod(nameof(CreateUtf8Stream), new[] { typeof(string) });
+
+        private static readonly MethodInfo _getStringMethod
+            = typeof(DbDataReader).GetRuntimeMethod(nameof(DbDataReader.GetString), new[] { typeof(int) });
+
+        public static MySqlStructuralJsonTypeMapping Default { get; } = new("json");
+
+        public MySqlStructuralJsonTypeMapping(string storeType)
+            : base(storeType, typeof(JsonTypePlaceholder), System.Data.DbType.String)
+        {
+        }
+
+        protected MySqlStructuralJsonTypeMapping(RelationalTypeMappingParameters parameters)
+            : base(parameters)
+        {
+        }
+
+        /// <summary>
+        /// MySQL stores JSON as strings, so we read using GetString.
+        /// </summary>
+        public override MethodInfo GetDataReaderMethod()
+            => _getStringMethod;
+
+        /// <summary>
+        /// Converts the string read from MySQL to a MemoryStream for EF Core's JSON processing.
+        /// </summary>
+        public static MemoryStream CreateUtf8Stream(string json)
+            => new MemoryStream(Encoding.UTF8.GetBytes(json ?? string.Empty));
+
+        /// <summary>
+        /// Customizes the data reader expression to convert string to MemoryStream.
+        /// </summary>
+        public override Expression CustomizeDataReaderExpression(Expression expression)
+            => Expression.Call(_createUtf8StreamMethod, expression);
+
+        protected override RelationalTypeMapping Clone(RelationalTypeMappingParameters parameters)
+            => new MySqlStructuralJsonTypeMapping(parameters);
+
+        protected string EscapeSqlLiteral(string literal)
+            => literal.Replace("'", "''");
+
+        protected override string GenerateNonNullSqlLiteral(object value)
+            => $"'{EscapeSqlLiteral((string)value)}'";
+
+        protected override void ConfigureParameter(DbParameter parameter)
+        {
+            // MySQL uses JSON db type for JSON columns
+            if (parameter is MySqlParameter mySqlParameter)
+            {
+                mySqlParameter.MySqlDbType = MySqlDbType.JSON;
+            }
+
+            base.ConfigureParameter(parameter);
+        }
+    }
+}

src/EFCore.MySql/Storage/Internal/MySqlTypeMappingSource.cs

@@ -87,10 +87,10 @@ private readonly RelationalTypeMapping _binaryRowVersion6
         // guid
         private GuidTypeMapping _guid;
 
-        // JSON default mapping
+        // JSON default mapping for regular JSON columns mapped to string
         private MySqlJsonTypeMapping<string> _jsonDefaultString;
-        // JSON mapping for complex types (JsonTypePlaceholder)
-        private MySqlJsonTypeMapping<System.IO.MemoryStream> _jsonComplex;
+        // JSON mapping for complex types (types mapped with .ToJson())
+        private MySqlStructuralJsonTypeMapping _jsonStructural;
 
         // Scaffolding type mappings
         private readonly MySqlCodeGenerationMemberAccessTypeMapping _codeGenerationMemberAccess = MySqlCodeGenerationMemberAccessTypeMapping.Default;
@@ -137,7 +137,7 @@ private void Initialize()
                 : null;
 
             _jsonDefaultString = new MySqlJsonTypeMapping<string>("json", null, null, _options.NoBackslashEscapes, _options.ReplaceLineBreaksWithCharFunction);
-            _jsonComplex = new MySqlJsonTypeMapping<System.IO.MemoryStream>("json", null, null, _options.NoBackslashEscapes, _options.ReplaceLineBreaksWithCharFunction);
+            _jsonStructural = new MySqlStructuralJsonTypeMapping("json");
 
             _storeTypeMappings
                 = new Dictionary<string, RelationalTypeMapping[]>(StringComparer.OrdinalIgnoreCase)
@@ -324,11 +324,10 @@ private RelationalTypeMapping FindRawMapping(RelationalTypeMappingInfo mappingIn
                     // fail immediately.
 
                     // Special case for JSON columns: EF Core passes JsonTypePlaceholder as the CLR type
-                    // when creating JSON columns for complex types/collections. Return our JSON mapping
-                    // with byte[] as ClrType so the CustomizeDataReaderExpression logic triggers conversion.
+                    // when creating JSON columns for complex types/collections. Return our structural JSON mapping.
                     if (clrType?.Name == "JsonTypePlaceholder" && storeTypeName.Equals("json", StringComparison.OrdinalIgnoreCase))
                     {
-                        return _jsonComplex;
+                        return _jsonStructural;
                     }
 
                     return clrType == null