ToQueryString on a split query only shows the first query

[ajcvickers]

For the query below, ToQueryString returns

SELECT [c].[Id]
FROM [Chunky] AS [c]
ORDER BY [c].[Id]

I would expect it to show all three queries that eventually get logged:

SELECT [c].[Id]
FROM [Chunky] AS [c]
ORDER BY [c].[Id]

SELECT [c0].[Id], [c0].[ChunkyId], [c].[Id]
FROM [Chunky] AS [c]
INNER JOIN [Cherry] AS [c0] ON [c].[Id] = [c0].[ChunkyId]
ORDER BY [c].[Id], [c0].[Id]

SELECT [m].[Id], [m].[CherryId], [c].[Id], [c0].[Id]
FROM [Chunky] AS [c]
INNER JOIN [Cherry] AS [c0] ON [c].[Id] = [c0].[ChunkyId]
INNER JOIN [Monkey] AS [m] ON [c0].[Id] = [m].[CherryId]
ORDER BY [c].[Id], [c0].[Id]

Code:

public class SomeDbContext : DbContext
{
    private static readonly ILoggerFactory
        Logger = LoggerFactory.Create(x => x.AddConsole());//.SetMinimumLevel(LogLevel.Debug));

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Chunky>();
    }
    
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder
            .UseLoggerFactory(Logger)
            .EnableSensitiveDataLogging()
            .UseSqlServer(Your.SqlServerConnectionString);
}

public static class Program
{
    public static void Main()
    {
        using (var context = new SomeDbContext())
        {
            context.Database.EnsureDeleted();
            context.Database.EnsureCreated();

            context.Add(new Chunky
            {
                Cherries = new List<Cherry>
                {
                    new Cherry
                    {
                        Monkeys = new List<Monkey> {new Monkey()}
                    }
                }
            });

            context.SaveChanges();
        }

        using (var context = new SomeDbContext())
        {
            var queryable = context.Set<Chunky>().Include(e => e.Cherries).ThenInclude(e => e.Monkeys).AsSplitQuery();
            Console.WriteLine(queryable.ToQueryString());
            queryable.ToList();
        }
    }
}

public class Chunky
{
    public int Id { get; set; }
    public ICollection<Cherry> Cherries { get; set; }
}

public class Cherry
{
    public int Id { get; set; }
    public ICollection<Monkey> Monkeys { get; set; }
}

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

[smitpatel]

By design. Other queries are not executed till first query actually enumerates and find a row to materialize. This was the reason ToQueryString feature was not implemented pre-3.0

[ajcvickers]

Note from triage: current plan is to do this when we implement query batching.

[Enngage]

Is there a way to get some unique hash from the IQueryable? I was using the sql text as a cache key, but this doesn't work when split queries are used. Or maybe there is some other alternative (other then using the single query)?

[ajcvickers]

@Enngage What, exactly, do you want to hash? Should it be the same if the query has different parameter values? What about constants? What about when different IQueryables generate the same SQL? Hashing a query is a complex question; even internally to EF we do it more than one way.

Have you considered using query tags? https://docs.microsoft.com/en-us/ef/core/querying/tags

[Enngage]

@aaronralls Thank you for getting back to me so quickly!

My question is probably a bit ambiguous. I was using the entire SQL query as a cache key, but this is not possible to do with the split query option in 5.0 because the ToQueryString gets only first SQL and therefore it would lead to multiple IQueryable objects having the same cache key.

Based on the conversion above, it is not yet possible to get all SQL queries so I was hoping there is a way to get reasonably unique hash from the IQueryable object that I could use instead of the full SQL query.

Tagging is a cool feature, but I don't think it helps in this case as I wouldn't know how to generate the tag in the first place.

[Phylum123]

I just solved that issue by using ".Expression.ToString();" on the IQueryable. Gives you a string representation of the query code itself.