Remove preparatory JSON infrastructure and debug code

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

Author: Copilot

src/EFCore.MySql/Metadata/Conventions/MySqlConventionSetBuilder.cs

@@ -44,12 +44,6 @@ public override ConventionSet CreateConventionSet()
             conventionSet.PropertyAddedConventions.Add(new ColumnCharSetAttributeConvention(Dependencies));
             conventionSet.PropertyAddedConventions.Add(new ColumnCollationAttributeConvention(Dependencies));
 
-            // Add JSON column convention to set store type for JSON-mapped complex properties
-            var jsonColumnConvention = new MySqlJsonColumnConvention(Dependencies, RelationalDependencies);
-            conventionSet.ComplexPropertyAddedConventions.Add(jsonColumnConvention);
-            conventionSet.ComplexPropertyAnnotationChangedConventions.Add(jsonColumnConvention);
-            conventionSet.ComplexTypeAnnotationChangedConventions.Add(jsonColumnConvention);
-
             var valueGenerationConvention = new MySqlValueGenerationConvention(Dependencies, RelationalDependencies);
             ReplaceConvention(conventionSet.EntityTypeBaseTypeChangedConventions, valueGenerationConvention);
             ReplaceConvention(conventionSet.EntityTypeAnnotationChangedConventions, (RelationalValueGenerationConvention)valueGenerationConvention);

src/EFCore.MySql/Metadata/Conventions/MySqlJsonColumnConvention.cs

@@ -164,31 +164,6 @@ public override IEnumerable<IAnnotation> For(IColumn column, bool designTime)
             var table = StoreObjectIdentifier.Table(column.Table.Name, column.Table.Schema);
             var properties = column.PropertyMappings.Select(m => m.Property).ToArray();
 
-            // Check if this is a container column for a JSON-mapped complex property
-            // Container columns don't have property mappings in the traditional sense
-            if (column.PropertyMappings.Count == 0 && column.Name != null)
-            {
-                // This might be a container column for a complex property
-                // Check if there's a complex property with this name that has JSON mapping
-                var entityTypes = column.Table.EntityTypeMappings.Select(m => m.TypeBase as IEntityType).Where(e => e != null);
-                foreach (var entityType in entityTypes)
-                {
-                    foreach (var complexProperty in entityType.GetComplexProperties())
-                    {
-                        // Cast to IReadOnlyTypeBase to access GetContainerColumnName
-                        var containerColumnName = (complexProperty.ComplexType as IReadOnlyTypeBase)?.GetContainerColumnName();
-                        if (containerColumnName == column.Name && complexProperty.GetJsonPropertyName() != null)
-                        {
-                            // This is a JSON container column - set the column type to "json"
-                            yield return new Annotation(
-                                RelationalAnnotationNames.ColumnType,
-                                "json");
-                            yield break;
-                        }
-                    }
-                }
-            }
-
             if (column.PropertyMappings.Where(
                     m => (m.TableMapping.IsSharedTablePrincipal ?? true) &&
                          m.TableMapping.TypeBase == m.Property.DeclaringType)

src/EFCore.MySql/Metadata/Internal/MySqlAnnotationProvider.cs

@@ -4,11 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Data.Common;
-using System.IO;
 using System.Linq;
-using System.Linq.Expressions;
-using System.Reflection;
-using System.Text;
 using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.ChangeTracking;
@@ -61,9 +57,6 @@ protected override RelationalTypeMapping Clone(bool? noBackslashEscapes = null,
 
     public abstract class MySqlJsonTypeMapping : MySqlStringTypeMapping, IMySqlCSharpRuntimeAnnotationTypeMappingCodeGenerator
     {
-        protected static readonly MethodInfo _getString
-            = typeof(DbDataReader).GetRuntimeMethod(nameof(DbDataReader.GetString), new[] { typeof(int) });
-
         public MySqlJsonTypeMapping(
             [NotNull] string storeType,
             [NotNull] Type clrType,
@@ -125,28 +118,6 @@ protected override void ConfigureParameter(DbParameter parameter)
             }
         }
 
-        /// <summary>
-        /// Returns the method to be used for reading JSON values from the database.
-        /// MySQL stores JSON as strings, so we use GetString instead of the default GetFieldValue&lt;T&gt;.
-        /// </summary>
-        public override MethodInfo GetDataReaderMethod()
-        {
-            Console.WriteLine($"[DEBUG] MySqlJsonTypeMapping.GetDataReaderMethod() called - ClrType: {ClrType.Name} - returning DbDataReader.GetString");
-            return _getString;
-        }
-
-        /// <summary>
-        /// Customizes the data reader expression for JSON types.
-        /// 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)
-        {
-            Console.WriteLine($"[DEBUG] MySqlJsonTypeMapping.CustomizeDataReaderExpression() called - ClrType: {ClrType.Name} - no conversion");
-            // For regular JSON columns, no conversion needed - just return the string
-            return base.CustomizeDataReaderExpression(expression);
-        }
-
         void IMySqlCSharpRuntimeAnnotationTypeMappingCodeGenerator.Create(
             CSharpRuntimeAnnotationCodeGeneratorParameters codeGeneratorParameters,
             CSharpRuntimeAnnotationCodeGeneratorDependencies codeGeneratorDependencies)

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

@@ -87,10 +87,8 @@ private readonly RelationalTypeMapping _binaryRowVersion6
         // guid
         private GuidTypeMapping _guid;
 
-        // JSON default mapping for regular JSON columns mapped to string
+        // JSON default mapping
         private MySqlJsonTypeMapping<string> _jsonDefaultString;
-        // JSON mapping for complex types (types mapped with .ToJson())
-        private MySqlStructuralJsonTypeMapping _jsonStructural;
 
         // Scaffolding type mappings
         private readonly MySqlCodeGenerationMemberAccessTypeMapping _codeGenerationMemberAccess = MySqlCodeGenerationMemberAccessTypeMapping.Default;
@@ -137,7 +135,6 @@ private void Initialize()
                 : null;
 
             _jsonDefaultString = new MySqlJsonTypeMapping<string>("json", null, null, _options.NoBackslashEscapes, _options.ReplaceLineBreaksWithCharFunction);
-            _jsonStructural = new MySqlStructuralJsonTypeMapping("json");
 
             _storeTypeMappings
                 = new Dictionary<string, RelationalTypeMapping[]>(StringComparer.OrdinalIgnoreCase)
@@ -204,10 +201,6 @@ private void Initialize()
                     { "time",                      new RelationalTypeMapping[] { _timeTimeOnly, _timeTimeSpan } },
                     { "datetime",                  new RelationalTypeMapping[] { _dateTime, _dateTimeOffset } },
                     { "timestamp",                 new RelationalTypeMapping[] { _timeStamp, _timeStampOffset } },
-
-                    // json - for complex types mapped with .ToJson()
-                    // This supports both MySQL 5.7.8+ (native JSON) and MariaDB 10.2.4+ (JSON as LONGTEXT alias)
-                    { "json",                      new[] { _jsonDefaultString } },
                 };
 
             _clrTypeMappings
@@ -312,15 +305,6 @@ private RelationalTypeMapping FindRawMapping(RelationalTypeMappingInfo mappingIn
             var storeTypeName = mappingInfo.StoreTypeName;
             var storeTypeNameBase = mappingInfo.StoreTypeNameBase;
 
-            // Special case for JSON columns: EF Core passes JsonTypePlaceholder as the CLR type
-            // when creating JSON columns for complex types/collections. Return our structural JSON mapping.
-            // This MUST be checked first, before any store type lookups, similar to SQL Server's implementation.
-            if (clrType?.Name == "JsonTypePlaceholder")
-            {
-                Console.WriteLine($"[DEBUG] MySqlTypeMappingSource: Detected JsonTypePlaceholder - returning MySqlStructuralJsonTypeMapping");
-                return _jsonStructural;
-            }
-
             if (storeTypeName != null)
             {
                 // First look for the fully qualified store type name.
@@ -331,7 +315,6 @@ private RelationalTypeMapping FindRawMapping(RelationalTypeMappingInfo mappingIn
                     // mapping as the default.
                     // If a CLR type was provided, look for a mapping between the store and CLR types. If none is found,
                     // fail immediately.
-                    
                     return clrType == null
                         ? mappings[0]
                         : mappings.FirstOrDefault(m => m.ClrType == clrType);
@@ -347,15 +330,9 @@ private RelationalTypeMapping FindRawMapping(RelationalTypeMappingInfo mappingIn
                             ?.WithTypeMappingInfo(in mappingInfo);
                 }
 
-                // Handle JSON store type for any CLR type
-                // This is needed for complex collections mapped with .ToJson() in EF Core 10+
-                // Works for both MySQL (native JSON type) and MariaDB (JSON alias for LONGTEXT)
-                if (storeTypeName.Equals("json", StringComparison.OrdinalIgnoreCase))
+                if (storeTypeName.Equals("json", StringComparison.OrdinalIgnoreCase) &&
+                    (clrType == null || clrType == typeof(string) || clrType == typeof(MySqlJsonString)))
                 {
-                    // Return JSON mapping for any CLR type since JSON can serialize any object
-                    // The "json" store type works for both:
-                    // - MySQL 5.7.8+: Creates native JSON column with binary storage
-                    // - MariaDB 10.2.4+: Creates LONGTEXT column with JSON validation constraint
                     return _jsonDefaultString;
                 }