Overloaded HasDbFunction throws NullReferenceException in ConcreteColumnExpression constructor

[DanielStout5]

Include your code

Creating two DbFunction overloads for OpenJson (one with a path parameter, one without) causes calls to the version with the second parameter to throw NullReferenceException:

        [DbFunction("OPENJSON", IsBuiltIn = true)]
        public static IQueryable<JsonResult> OpenJson(object json) => throw new NotSupportedException();

        [DbFunction("OPENJSON", IsBuiltIn = true)]
        public static IQueryable<JsonResult> OpenJson(object json, string path) => throw new NotSupportedException();

Either one works by itself, but having both causes the NullReferenceException

Complete example: https://github.com/DanielStout5/EfCoreOpenJson/blob/DbFunctionOverload/Models/MyDbContext.cs

Include stack traces

System.NullReferenceException: Object reference not set to an instance of an object.
   at Microsoft.EntityFrameworkCore.Query.SqlExpressions.SelectExpression.ConcreteColumnExpression..ctor(IProperty property, IColumnBase column, TableReferenceExpression table, Boolean nullable)
   at Microsoft.EntityFrameworkCore.Query.SqlExpressions.SelectExpression.CreateColumnExpression(IProperty property, IColumnBase columnBase, TableReferenceExpression tableExpression, Boolean nullable)
   at Microsoft.EntityFrameworkCore.Query.SqlExpressions.SelectExpression.CreateColumnExpression(IProperty property, ITableBase table, TableReferenceExpression tableExpression, Boolean nullable)
   at Microsoft.EntityFrameworkCore.Query.SqlExpressions.SelectExpression..ctor(IEntityType entityType, TableExpressionBase tableExpressionBase)
   at Microsoft.EntityFrameworkCore.Query.SqlExpressionFactory.Select(IEntityType entityType, TableExpressionBase tableExpressionBase)
   at Microsoft.EntityFrameworkCore.Query.RelationalQueryableMethodTranslatingExpressionVisitor.VisitExtension(Expression extensionExpression)
   at Microsoft.EntityFrameworkCore.SqlServer.Query.Internal.SqlServerQueryableMethodTranslatingExpressionVisitor.VisitExtension(Expression extensionExpression)
   at Microsoft.EntityFrameworkCore.Query.QueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
   at Microsoft.EntityFrameworkCore.Query.RelationalQueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
   at Microsoft.EntityFrameworkCore.Query.RelationalQueryableMethodTranslatingExpressionVisitor.TranslateSelectMany(ShapedQueryExpression source, LambdaExpression collectionSelector, LambdaExpression resultSelector)
   at Microsoft.EntityFrameworkCore.Query.QueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
   at Microsoft.EntityFrameworkCore.Query.RelationalQueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
   at Microsoft.EntityFrameworkCore.Query.QueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
   at Microsoft.EntityFrameworkCore.Query.RelationalQueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
   at Microsoft.EntityFrameworkCore.Query.QueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
   at Microsoft.EntityFrameworkCore.Query.RelationalQueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
   at Microsoft.EntityFrameworkCore.Query.QueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
   at Microsoft.EntityFrameworkCore.Query.RelationalQueryableMethodTranslatingExpressionVisitor.VisitMethodCall(MethodCallExpression methodCallExpression)
   at Microsoft.EntityFrameworkCore.Query.QueryCompilationContext.CreateQueryExecutor[TResult](Expression query)
   at Microsoft.EntityFrameworkCore.Storage.Database.CompileQuery[TResult](Expression query, Boolean async)
   at Microsoft.EntityFrameworkCore.Query.Internal.QueryCompiler.CompileQueryCore[TResult](IDatabase database, Expression query, IModel model, Boolean async)
   at Microsoft.EntityFrameworkCore.Query.Internal.QueryCompiler.<>c__DisplayClass12_0`1.<ExecuteAsync>b__0()
   at Microsoft.EntityFrameworkCore.Query.Internal.CompiledQueryCache.GetOrAddQuery[TResult](Object cacheKey, Func`1 compiler)
   at Microsoft.EntityFrameworkCore.Query.Internal.QueryCompiler.ExecuteAsync[TResult](Expression query, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryProvider.ExecuteAsync[TResult](Expression expression, CancellationToken cancellationToken)
   at Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryable`1.GetAsyncEnumerator(CancellationToken cancellationToken)
   at System.Runtime.CompilerServices.ConfiguredCancelableAsyncEnumerable`1.GetAsyncEnumerator()
   at Microsoft.EntityFrameworkCore.EntityFrameworkQueryableExtensions.ToListAsync[TSource](IQueryable`1 source, CancellationToken cancellationToken)

Include provider and version information

EF Core version: 7.0.11
Database provider: Microsoft.EntityFrameworkCore.SqlServer
Target framework: (e.g. .NET 6.0) .Net 7.0
Operating system: Windows 10
IDE: (e.g. Visual Studio 2022 17.4) 17.9.6

[maumar]

I verified this repros on 8.0 as well but works on current bits (after correcting for a small bug in relational model)

[maumar]

(somewhat) simplified repro:

    [ConditionalFact]
    public async Task MyRepro()
    {
        using var ctx = new MyDbContext();
        await ctx.Database.EnsureDeletedAsync();
        await ctx.Database.EnsureCreatedAsync();



        var result = await ctx.Books.OrderBy(x => x.Title)
            .SelectMany(x => MyDbContext.OpenJson(x.Data!, "$.Genres").Select(x => x.Value))
            .Distinct()
            .OrderBy(x => x)
            .ToListAsync();
    }

#nullable enable

    public class MyDbContext : DbContext
    {
#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
        public DbSet<Book> Books { get; set; }

        public DbSet<BookCover> BookCovers { get; set; }
#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.

        [DbFunction("OPENJSON", IsBuiltIn = true)]
        public static IQueryable<JsonResult> OpenJson(object json) => throw new NotSupportedException();

        [DbFunction("OPENJSON", IsBuiltIn = true)]
        public static IQueryable<JsonResult> OpenJson(object json, string path) => throw new NotSupportedException();

        protected override void OnModelCreating(ModelBuilder builder)
        {
            builder.HasDbFunction(typeof(MyDbContext).GetMethod(nameof(OpenJson), new[] { typeof(object) })!, b => b.HasParameter("json").HasStoreType("nvarchar(max)"));
            builder.HasDbFunction(typeof(MyDbContext).GetMethod(nameof(OpenJson), new[] { typeof(object), typeof(string) })!, b => b.HasParameter("json").HasStoreType("nvarchar(max)"));


            builder.Entity<Book>(b => b.Property(x => x.Data).IsJson());

            // Prevent migration error "Cannot scaffold C# literals of type 'System.Reflection.NullabilityInfoContext'"
            // See: https://github.com/dotnet/efcore/issues/30142
            // We also need to exclude it from migrations to prevent EF core from trying to add a table for it
            builder.Entity<JsonResult>().ToTable(nameof(JsonResult)).Metadata.SetIsTableExcludedFromMigrations(true);
        }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=Repro;Trusted_Connection=True;MultipleActiveResultSets=true");
        }

        [Keyless]
        public class JsonResult
        {
            public required string Key { get; set; }

            public required string Value { get; set; }

            public int Type { get; set; }
        }
    }


    public class Book
    {
        public int Id { get; set; }

        public required string Title { get; set; }

        public Dictionary<string, object>? Data { get; set; }

        public List<BookCover> Covers { get; set; } = new();

        public DateTime? PublishAt { get; set; }

        public DateTime? HideAt { get; set; }
    }

    public class BookCover
    {
        public int Id { get; set; }

        public int BookId { get; set; }

        public Book? Book { get; set; }
    }
}


public static class ModelBuilderExtensions
{
    private static PropertyBuilder<T> AddJsonConverter<T>(this PropertyBuilder<T> bldr,
        ValueConverter<T, string> converter)
    {
#pragma warning disable CS8603 // Possible null reference return.
        var comp = new ValueComparer<T>(
            (l, r) => IsEqual(l, r),
            v => FindHashCode(v),
            v => JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(v)));

        bldr.HasConversion(converter, comp);
        return bldr;
    }

    /// <summary>
    /// Marks a field as being stored as JSON in the database, using the default value for
    /// the field type if it's stored as null
    /// </summary>
    public static PropertyBuilder<T> IsJson<T>(
        this PropertyBuilder<T> bldr,
        JsonSerializerSettings? settings = null
        )
    {
        var conv = new ValueConverter<T, string>(
            v => JsonConvert.SerializeObject(v, settings),
            v => v == null ? default : JsonConvert.DeserializeObject<T>(v, settings)
#pragma warning restore CS8603 // Possible null reference return.
        );

        return AddJsonConverter(bldr, conv);
    }

    private static int FindHashCode<T>(T val)
    {
        if (val is IEnumerable list)
        {
            // https://stackoverflow.com/a/8094931/10260374
            unchecked
            {
                int hash = 19;
                foreach (var foo in list)
                {
                    hash = hash * 31 + foo.GetHashCode();
                }
                return hash;
            }
        }

#pragma warning disable CS8602 // Dereference of a possibly null reference.
        return val.GetHashCode();
#pragma warning restore CS8602 // Dereference of a possibly null reference.
    }

    private static bool IsEqual<T>(T l, T r)
    {
        if (l == null || r == null)
        {
            return ReferenceEquals(l, r);
        }

        var defEq = Equals(l, r);

        if (defEq)
        {
            return true;
        }

        if (l is ICollection lCol && r is ICollection rCol)
        {
            if (lCol.Count != rCol.Count) return false;
            // No need to check rCol count because we know counts are the same here
            if (lCol.Count == 0) return true;

            // Otherwise if collections are non-empty with same number of items we need to serialize them to confirm
        }

        var lJson = JsonConvert.SerializeObject(l);
        var rJson = JsonConvert.SerializeObject(r);
        return lJson == rJson;
    }
}

#nullable disable

[maumar]

Note: on main the NRE is gone, and the error happens because RelationalModel -> IRelationalModel.Functions
tries to order functions based on dictionary key, which is (string, string?, IReadOnlyList<string>) (name, schema, arg types).
If two functions have the same name and schema, we get the error because IReadOnlyList<string> is not IComparable.
This usually won't happen for user generated functions, but could happen for build-in functions like OPENJSON. Not a very common scenario, especially given that we had this bug since 7.0 and this is the first time it was reported.

[DanielStout5]

Thanks for looking into this @maumar - any thoughts for an interim workaround until a fix is released?

[DanielStout5]

Found an easy workaround - just use different capitalization in the attributes:

        [DbFunction("OPENJSON", IsBuiltIn = true)]
        public static IQueryable<JsonItem> OpenJson(object json, string path) => throw new NotSupportedException();

        [DbFunction("openjson", IsBuiltIn = true)]
        public static IQueryable<JsonItem> OpenJson(object json) => throw new NotSupportedException();