Discriminator not updated when replacing TPH entity via Remove+Add with same ID — is this intentional in EF 9?

[tpavlackyYunex]

Question

In EF Core 8, replacing a TPH entity in a collection by removing the old instance and adding a new instance with the same ID generates an UPDATE that includes the Discriminator column. In EF Core 9, the Discriminator is no longer included in the UPDATE, so the type change is silently lost.

I'm not sure whether the EF 8 behaviour was correct (and this is a regression), or whether EF 9 is correctly rejecting a pattern that was never meant to be supported. I found two issues that seem to be related to this issue and may suggest that this is valid use case:

• Discriminator change in TPH does not null obsolete columns when reusing key #36308 shows EF Core 8 issuing an UPDATE with a changed discriminator in a similar scenario, implying it was working and accepted behaviour.
• How to change the type of a single entity in a one-to-many collection? #30611 one of the comments says: we do allow this with TPH if the discriminator is mapped as a property that can still be changed after it has been saved for the first time.

Output of the provided example

SQL generated by EF Core 8

UPDATE "Commands" SET "Discriminator" = @p0, "Label" = @p1
WHERE "Id" = @p2
RETURNING 1;

SQL generated by EF Core 9

UPDATE "Commands" SET "DayPlanId" = @p0, "Label" = @p1
WHERE "Id" = @p2
RETURNING 1;

The Discriminator column is absent from the EF 9 UPDATE.

Your code

using Microsoft.EntityFrameworkCore;

using var initCtx = new AppDbContext();
initCtx.Database.EnsureDeleted();
initCtx.Database.EnsureCreated();

// 1. Seed a CommandA
var dayPlan = new DayPlan { Name = "Day 1" };
var original = new CommandA { Label = "Original A" };
dayPlan.Commands.Add(original);
initCtx.DayPlans.Add(dayPlan);
initCtx.SaveChanges();

Console.WriteLine($"Seeded: Id={original.Id}, Type={original.GetType().Name}");
PrintDb(initCtx);

// 2. Replace CommandA with CommandB
using var ctx = new AppDbContext();

var loadedPlan = ctx.DayPlans.Include(d => d.Commands).First();
var oldCmd = loadedPlan.Commands.First();
var newCmd = new CommandB { Label = "replaced B" };

// Replace CommandA with CommandB => preserve ID
loadedPlan.Commands.Remove(oldCmd);
newCmd.Id = oldCmd.Id;
loadedPlan.Commands.Add(newCmd);

Console.WriteLine($"Before SaveChanges:");
foreach (var entry in initCtx.ChangeTracker.Entries<Command>())
{
  Console.WriteLine($"  [{entry.State}] {entry.Entity.GetType().Name} Id={entry.Entity.Id}");
}

Console.WriteLine($"Replacing commands:");
ctx.SaveChanges();

Console.WriteLine($"After SaveChanges:");
PrintDb(ctx);

// Load from DB via new instance of the context
Console.WriteLine($"Fresh context:");
using var freshCtx = new AppDbContext();
PrintDb(freshCtx);

static void PrintDb(AppDbContext ctx)
{
  ctx.ChangeTracker.Clear();
  var rows = ctx.DayPlans.Include(d => d.Commands).First().Commands;
  foreach (var c in rows)
  {
    Console.WriteLine($"  DB row: Id={c.Id}, Type={c.GetType().Name}, Label={c.Label}");
  }
}

// -----------------------------------------------------------------------
// Model
// -----------------------------------------------------------------------
public class DayPlan
{
  public int Id { get; set; }
  public string Name { get; set; } = "";
  public ICollection<Command> Commands { get; set; } = new List<Command>();
}

public abstract class Command
{
  public int Id { get; set; }
  public string Label { get; set; } = "";
  public int DayPlanId { get; set; }
}

public class CommandA : Command { }
public class CommandB : Command { }

// -----------------------------------------------------------------------
// DbContext — SQLite in-memory for zero setup
// -----------------------------------------------------------------------
public class AppDbContext : DbContext
{
  public DbSet<DayPlan> DayPlans => Set<DayPlan>();
  public DbSet<Command> Commands => Set<Command>();

  protected override void OnModelCreating(ModelBuilder modelBuilder)
  {
    modelBuilder.Entity<Command>()
        .HasDiscriminator<string>("Discriminator")
        .HasValue<CommandA>("CommandA")
        .HasValue<CommandB>("CommandB");
  }

  protected override void OnConfiguring(DbContextOptionsBuilder o) =>
      o.UseSqlite("Data Source=repro.db")
       .LogTo(msg =>
       {
         // Only print SQL statements, skip noise
         if (msg.Contains("Executed DbCommand"))
         { 
           Console.WriteLine(msg); 
         }
       }, Microsoft.Extensions.Logging.LogLevel.Information);
}

Stack traces

Verbose output

EF Core version

9.0.0

Database provider

Microsoft.EntityFrameworkCore.Sqlite

Target framework

No response

Operating system

No response

IDE

No response

[roji]

AI Triage

The below is an AI-generated analysis and may contain inaccuracies.

I can reproduce this with the SQLite provider, and it looks like an EF Core 9 regression.

With the repro below:

• EF Core 8.0.17 generates an update including the discriminator:

UPDATE "Commands" SET "Discriminator" = @p0, "Label" = @p1
WHERE "Id" = @p2
RETURNING 1;

Reloading the row materializes CommandB.

• EF Core 9.0.0 and 9.0.16 generate an update which does not include the discriminator:

UPDATE "Commands" SET "DayPlanId" = @p0, "Label" = @p1
WHERE "Id" = @p2
RETURNING 1;

Reloading the row still materializes CommandA, so the type replacement is silently lost.

This seems closely related to/covered by #30705, which tracks stopping the delete+insert-to-update collapsing behavior. #36308 is also related and was closed as covered by #30705; #30611 has the earlier discussion around this pattern.

minimal repro

Package:

<PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.16" />

Program:

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;

using var context = new TestContext();
await context.Database.EnsureDeletedAsync();
await context.Database.EnsureCreatedAsync();

var dayPlan = new DayPlan { Name = "Day 1" };
var original = new CommandA { Label = "Original A" };
dayPlan.Commands.Add(original);
context.Add(dayPlan);
await context.SaveChangesAsync();

context.ChangeTracker.Clear();

var loadedPlan = await context.DayPlans.Include(d => d.Commands).SingleAsync();
var oldCommand = loadedPlan.Commands.Single();
var newCommand = new CommandB { Id = oldCommand.Id, Label = "Replaced B" };

loadedPlan.Commands.Remove(oldCommand);
loadedPlan.Commands.Add(newCommand);

await context.SaveChangesAsync();

context.ChangeTracker.Clear();

var command = await context.Commands.SingleAsync();
Console.WriteLine(command.GetType().Name);

public class TestContext : DbContext
{
    public DbSet<DayPlan> DayPlans => Set<DayPlan>();
    public DbSet<Command> Commands => Set<Command>();

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder
            .UseSqlite("Data Source=repro.db")
            .LogTo(Console.WriteLine, LogLevel.Information)
            .EnableSensitiveDataLogging();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
        => modelBuilder.Entity<Command>()
            .HasDiscriminator<string>("Discriminator")
            .HasValue<CommandA>("CommandA")
            .HasValue<CommandB>("CommandB");
}

public class DayPlan
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public ICollection<Command> Commands { get; } = new List<Command>();
}

public abstract class Command
{
    public int Id { get; set; }
    public string Label { get; set; } = "";
    public int DayPlanId { get; set; }
}

public class CommandA : Command;

public class CommandB : Command;