Query: Prevent client evaluation when using certain result operators in complex query

Steps to reproduce

await
                        db.ProxyServerLoadResult.AsNoTracking()
                            .Include(x => x.ProxyServer)
                            .Where(x => !x.ProxyServer.BlockedByOperator)
                            .Where(x => x.SourceId == 1)
                            .OrderByDescending(x => x.Score)
                            .Take(100)
                            .Select(x => x.ProxyServer)
                            .ToListAsync();

The issue

I guess this warning is wrong. Am I right?

Exception message:

Warning as error exception for warning 'RelationalEventId.QueryClientEvaluationWarning': The LINQ expression 'join ProxyServer x.ProxyServer in value(Microsoft.EntityFrameworkCore.Query.Internal.EntityQueryable`1[RP.DataModel.ProxyServer]) on Property([x], "ProxyServerId") equals Property([x.ProxyServer], "ProxyServerId")' could not be translated and will be evaluated locally. To suppress this Exception use the DbContextOptionsBuilder.ConfigureWarnings API. ConfigureWarnings can be used when overriding the DbContext.OnConfiguring method or using AddDbContext on the application service provider.

Further technical details

EF Core version: 1.1.0 Operating system: Windows 10 Visual Studio version: VS2015U3

[maumar]

@AsValeO as a workaround try putting Take(100) at the end of the query like so:

await
                        db.ProxyServerLoadResult.AsNoTracking()
                            .Include(x => x.ProxyServer)
                            .Where(x => !x.ProxyServer.BlockedByOperator)
                            .Where(x => x.SourceId == 1)
                            .OrderByDescending(x => x.Score)
                            .Select(x => x.ProxyServer)
                            .Take(100)
                            .ToListAsync();

this produces a much simpler query from the EF perspective, that we are able to fully translate at the moment. If possible, you should always try to put Skip/Take/Distinct as the last operation when using EF Core (at least until we address the current limitations).

The reason is that those are what we call ResultOperators - they are always the last operation in a given query. If there are more operations following, we introduce subqueries, which complicates the translation significantly for some cases. E.g. the original intermediate model representation for your original query is:

from ProxyServerLoadResult x in 
    (from ProxyServerLoadResult x in DbSet<ProxyServerLoadResult>
    join ProxyServer x.ProxyServer in DbSet<ProxyServer>
    on Property(x, "ProxyServerId") equals Property(x.ProxyServer, "ProxyServerId")
    where !(x.ProxyServer.BlockedByOperator)
    where x.SourceId == 1
    order by x.Score desc
    select x)
    .Take(__p_0)
join ProxyServer x.ProxyServer in DbSet<ProxyServer>
on Property(x, "ProxyServerId") equals Property(x.ProxyServer, "ProxyServerId")
select x.ProxyServer

and the proposed workaround:

(from ProxyServerLoadResult x in DbSet<ProxyServerLoadResult>
join ProxyServer x.ProxyServer in DbSet<ProxyServer>
on Property(x, "ProxyServerId") equals Property(x.ProxyServer, "ProxyServerId")
where !(x.ProxyServer.BlockedByOperator)
where x.SourceId == 1
order by x.Score desc
select x.ProxyServer)
.Take(__p_0)

[mguinness]

@maumar I think I’ve encountered this issue also. When you say fixed, do you mean this will be included in the Entity Framework Core 2.0 release?

EDIT: I see it was included in preview 1 https://github.com/aspnet/EntityFramework/releases/tag/rel%2F2.0.0-preview1