Fix unnecessary joins in consecutive Select projections with conditionals

[Copilot]

Consecutive .Select() operations with conditional null checks were projecting all properties from earlier selects, generating unnecessary joins and columns in SQL.

users
    .Select(x => new { 
        x.Id, 
        Job = x.Job == null ? null : new { 
            x.Job.Id, 
            Address = new { x.Job.Address.Id, x.Job.Address.Street } 
        } 
    })
    .Select(x => new { 
        x.Id, 
        Job = x.Job == null ? null : new { x.Job.Id }  // Only accessing Id
    })

Generated SQL incorrectly included Address table joins and columns despite the second select only referencing Job.Id.

Changes

Core Fix (NavigationExpandingExpressionVisitor.ExpressionVisitors.cs)

• Added NavigationTreeMemberPruningVisitor that rewrites composed selectors before navigation expansion using three rules:
  1. (new { A = a, B = b }).A → a — prunes unused branches from anonymous-type projections
  2. (test ? null : ifFalse).M → ifFalse.M — folds member access through null-safe conditionals
  3. (test ? null : new { M = ... }) == null → test — simplifies null checks on conditional new-expressions

Tests

• Added Consecutive_selects_with_conditional_projection_should_not_include_unnecessary_joins — verifies generated SQL excludes unreferenced navigation joins
• Added Consecutive_selects_with_conditional_projection_null_navigation_returns_null — verifies null navigation is correctly returned as null
• Added Consecutive_selects_with_conditional_projection_nested_navigation_accessed_includes_join — verifies referenced navigations still produce their joins
• Strengthened Consecutive_selects_with_conditional_projection_should_not_include_unnecessary_joins with materialization assertions for result.Job and result.Job.Id
• Added SQL Server functional test overrides with SQL baselines for all three consecutive conditional projection tests to validate provider-specific generated SQL shape

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Checking parameter for null causes incorrect projections translation</issue_title>
<issue_description>### Bug description

This is a copy of npgsql/efcore.pg#3295

Hello,

When checking a joined entity for NULL the further projecting of joined table does not take effect causing always selecting all fields and all subsequent joins if any.

Suppose having following entity hierarchy: User -> Job? -> Address

class User {
  public long Id { get; set; }
  public long? JobId { get; set; }
  // other unrelated properties
}

class Job {
 public long Id { get; set; }
 public long AddressId { get; set; }
 // other unrelated properties
}

class Address {
 public long Id { get; set; }
 // other unrelated properties
}

The following linq query

        var claim = await users
            .Select(x => new
            {
                x.Id,
                Job = x.Job == null ? null : new
                {
                    x.Job.Id,
                    Address = new
                    {
                        x.Job.Address.Id,
                        x.Job.Address.Street
                    }
                }
            })
            .Select(x => new
            {
                x.Id,
                Job = x.Job == null ? null : new
                {
                    x.Job.Id
                }
            })
            .Where(x => x.Id == 14501)
            .FirstOrDefaultAsync();

produces this sql:

SELECT c."Id", c0."Id", FALSE, c1."Id", c1."Street"
FROM "User" AS c
INNER JOIN "Job" AS c0 ON c."JobId" = c0."Id"
INNER JOIN "Address" AS c1 ON c0."AddressId" = c1."Id"
WHERE c."Id" = 14501

It includes join to Address table, even though it is not selected in the last Select method.

You may ask why doing consequent selects, the answer is the part before second select may come from elsewhere as IQueryable which you want to further narrow down.

Anyways, is that expected? And is it possible to workaround?

Your code

see description

Stack traces

Verbose output

EF Core version

9.0.0

Database provider

Npgsql.EntityFrameworkCore.PostgreSQL.9.0.1

Target framework

No response

Operating system

MAC OS

IDE

Jetbrains Rider</issue_description>

Comments on the Issue (you are @copilot in this section)

@cincuranet Small repro:

using Microsoft.EntityFrameworkCore;

using var db = new MyContext();
Console.WriteLine(db.Users
    .Select(x => new
    {
        x.Id,
        Job = x.Job == null ? null : new
        {
            x.Job.Id,
            Address = new
            {
                x.Job.Address.Id,
                x.Job.Address.Street
            }
        }
    })
    .Select(x => new
    {
        x.Id,
        Job = x.Job == null ? null : new
        {
            x.Job.Id
        }
    })
    .Where(x => x.Id == 14501)
    .ToQueryString());

class MyContext : DbContext
{
    public DbSet<User> Users { get; set; } = null!;

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlite();
    }
}
class User
{
    public long Id { get; set; }
    public long? JobId { get; set; }
    public Job? Job { get; set; }
}
class Job
{
    public long Id { get; set; }
    public long AddressId { get; set; }
    public Address Address { get; set; } = null!;
}
class Address
{
    public long Id { get; set; }
    public string Street { get; set; } = null!;
}

BTW, removing the second conditional (the x.Job == null ? null : new) "fixes" it. </comment_new>

• Fixes Checking parameter for null causes incorrect projections translation #35518

---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.

[Copilot]

Pull request overview

This PR addresses a query translation inefficiency where consecutive Select() projections combined with conditional null checks would cause EF Core to keep projecting earlier navigation members, resulting in unnecessary joins/columns in generated SQL. The change is implemented in the navigation-expansion pipeline and validated with a new relational test plus a SQLite SQL baseline to ensure the unreferenced navigation join is eliminated.

Changes:

• Adjust navigation expansion/member access handling to avoid expanding/reconstructing entire anonymous-type navigation shapes when only a specific member is accessed.
• Add a new relational specification test covering consecutive conditional projections.
• Add a SQLite functional test override asserting the absence of the unnecessary join in generated SQL.

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 4 comments.

File	Description
src/EFCore/Query/Internal/NavigationExpandingExpressionVisitor.ExpressionVisitors.cs	Adds/changes visitors to prune navigation-tree member expansions so later projections don’t carry unused navigation joins.
src/EFCore/Query/Internal/NavigationExpandingExpressionVisitor.cs	Runs the new pruning visitor during Select processing.
test/EFCore.Relational.Specification.Tests/Query/AdHocNavigationsQueryRelationalTestBase.cs	Adds a new relational spec test reproducing the consecutive conditional projection scenario.
test/EFCore.Sqlite.FunctionalTests/Query/AdHocNavigationsQuerySqliteTest.cs	Adds SQL assertion ensuring the generated query doesn’t include the unnecessary join.

[Copilot]

Pull request overview

Copilot reviewed 4 out of 4 changed files in this pull request and generated 1 comment.

[Copilot]

Pull request overview

Copilot reviewed 5 out of 5 changed files in this pull request and generated 1 comment.

[Copilot]

Pull request overview

Copilot reviewed 5 out of 5 changed files in this pull request and generated no new comments.