OwnOne entities with default values not saved in TPH scenario

[Tyf0x]

Bug description

When using Table-Per-Hierarchy (TPH) inheritance with owned entities (OwnsOne), EF Core 8 generates an UPDATE statement but omits the owned entity columns when:

• An owned entity property starts as null in the database
• It's then set to an instance where all properties have their CLR default values (e.g., EnumValue.Unknown = 0, IsBool = false)
• Nullable reference types are disabled (disable in the project file)

This leads to data corruption, preventing us from effectively upgrading from EF core 7 to EF core 8/9/10.

Please find a sample repro project attached.
EfCoreEnumNullTest.zip

EF Core version

8/9/10

Database provider

SqlServer

Target framework

.NET 10

IDE

rider

[roji]

AI answer

Reproduction Confirmed

I've successfully reproduced this issue. This is a regression affecting EF Core 8 and 9, which has been fixed in EF Core 10.

Symptoms

When using TPH (Table-Per-Hierarchy) inheritance with owned entities (OwnsOne) where <Nullable>disable</Nullable> is set in the project, and setting an owned entity with CLR default values (e.g., EnumValue.Unknown = 0, IsBool = false), EF Core 8/9 fails to generate an UPDATE statement. This results in the database retaining NULL values instead of the expected default values.

Version Testing Results

EF Core 7: ✅ Works correctly - generates UPDATE statement with owned entity columns
EF Core 8: ❌ Broken - no UPDATE statement generated, values remain NULL
EF Core 9: ❌ Broken - no UPDATE statement generated, values remain NULL
EF Core 10: ✅ Fixed - generates UPDATE statement with owned entity columns

Minimal repro

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

var childA = new ChildA();
context.Parents.Add(childA);
await context.SaveChangesAsync();
var childId = childA.Id;

context.ChangeTracker.Clear();

var loaded = await context.Parents.OfType<ChildA>().SingleAsync(c => c.Id == childId);
loaded.SetShared(SharedType.Create(EnumValue.Unknown, false));

await context.SaveChangesAsync();

context.ChangeTracker.Clear();

var verified = await context.Parents.OfType<ChildA>().SingleAsync(c => c.Id == childId);
Console.WriteLine($"EnumValue: {verified.Shared?.EnumValue} (expected: Unknown)");
Console.WriteLine($"IsBool: {verified.Shared?.IsBool} (expected: False)");

public abstract class Parent
{
    public int Id { get; set; }
}

public class ChildA : Parent
{
    public SharedType Shared { get; private set; }

    public void SetShared(SharedType shared)
    {
        Shared = shared ?? throw new ArgumentNullException(nameof(shared));
    }
}

public class ChildB : Parent
{
    public SharedType Shared { get; private set; }

    public void SetShared(SharedType shared)
    {
        Shared = shared ?? throw new ArgumentNullException(nameof(shared));
    }
}

public class SharedType
{
    protected SharedType() { }

    private SharedType(EnumValue enumValue, bool isBool)
    {
        EnumValue = enumValue;
        IsBool = isBool;
    }

    public EnumValue EnumValue { get; private set; }
    public bool IsBool { get; private set; }

    public static SharedType Create(EnumValue enumValue, bool isBool)
        => new(enumValue, isBool);
}

public enum EnumValue
{
    Unknown,
    Pass,
    Fail
}

public class BlogContext : DbContext
{
    public DbSet<Parent> Parents => Set<Parent>();

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder
            .UseSqlServer(Environment.GetEnvironmentVariable("Test__SqlServer__DefaultConnection"))
            .LogTo(Console.WriteLine, Microsoft.Extensions.Logging.LogLevel.Information)
            .EnableSensitiveDataLogging();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Parent>()
            .HasDiscriminator<string>("ChildType")
            .HasValue<ChildA>("ChildA")
            .HasValue<ChildB>("ChildB");

        modelBuilder.Entity<ChildA>().OwnsOne(c => c.Shared, sb =>
        {
            sb.Property(s => s.EnumValue).HasConversion<string>();
        });

        modelBuilder.Entity<ChildB>().OwnsOne(c => c.Shared, sb =>
        {
            sb.Property(s => s.EnumValue).HasConversion<string>();
        });
    }
}

[roji]

@Tyf0x based on the above AI analysis, I'm going to go ahead and close this as a duplicate of #27509; assuming that analysis is correct, this was indeed a regression in 8 and 9, but has been fixed in 10. Can you please test with your repro on the EF 10 and confirm whether this is true? If not, can you please submit a simple console program minimal repro (as in the above comment) that shows the failure on EF 10?

[Tyf0x]

@Tyf0x based on the above AI analysis, I'm going to go ahead and close this as a duplicate of #27509; assuming that analysis is correct, this was indeed a regression in 8 and 9, but has been fixed in 10. Can you please test with your repro on the EF 10 and confirm whether this is true? If not, can you please submit a simple console program minimal repro (as in the above comment) that shows the failure on EF 10?

Hi @roji , we actually opened this bug because it happened after our upgrade to EF 10 (in production 🫠).
We chose to demonstrate it in the earliest version we found it to happen (EF 8).

I'll try replicate again tomorrow using EF 10 in the supplied project and post back.

[roji]

OK; please do your best to submit a simple single-file console app repro (see the minimal repro in the previous) to make it as minimal as possible.

Regardless, after a 2nd look this doesn't seem like a duplicate of #27509.

[Tyf0x]

Hi @roji, we can confirm this is also happening for EF 10.0.2

Please make sure you use EF database first using the script attached.

Minimal repro

CreateDatabase.sql

-- Run this script in SSMS to create the test database and tables
-- TPH inheritance test with Parent/Child hierarchy

-- Create database if not exists
IF NOT EXISTS (SELECT * FROM sys.databases WHERE name = 'DefaultPropertyRepro')
BEGIN
    CREATE DATABASE [DefaultPropertyRepro];
END
GO

USE [DefaultPropertyRepro];
GO

-- Drop existing tables if they exist
IF OBJECT_ID('THPTest.SharedType', 'U') IS NOT NULL
DROP TABLE [THPTest].[SharedType];
GO

-- Drop and recreate schema
IF SCHEMA_ID('THPTest') IS NOT NULL
DROP SCHEMA [THPTest];
GO

CREATE SCHEMA [THPTest];
GO

-- Create Parent table with TPH (Table-Per-Hierarchy) inheritance
-- ChildA and ChildB share this table
CREATE TABLE [THPTest].[SharedType] (
    [ChildId] INT IDENTITY(1,1) NOT NULL,

    -- TPH Discriminator column
    [ChildType] VARCHAR(100) NOT NULL,

    -- SharedType owned entity columns
    [Shared_IsBool] BIT NULL,
    [Shared_EnumValue] VARCHAR(50) NULL,
    );
GO

PRINT 'Database and tables created successfully!';
GO

Program.cs

#:package Microsoft.EntityFrameworkCore.SqlServer@10.0.2
#nullable disable

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

await new ApplicationSyncFlow().RunSingleCaseAsync();

// ============================================================================
// ENUMS
// ============================================================================

/// <summary>
/// Enum with Unknown as value 0 (default)
/// </summary>
public enum EnumValue
{
    Unknown,  // Value 0 - DEFAULT!
    Pass,     // Value 1
    Fail      // Value 2
}

// ============================================================================
// ENTITIES
// ============================================================================

/// <summary>
/// Abstract base class for TPH inheritance.
/// </summary>
public abstract class Parent
{
    public int Id { get; set; }
}

/// <summary>
/// ChildA - inherits from Parent (TPH inheritance).
/// </summary>
public class ChildA : Parent
{
    public SharedType Shared { get; private set; }

    public void SetSharedType(SharedType shared)
    {
        if (shared == null)
            throw new ArgumentNullException(nameof(shared));

        if (Shared == shared)
        {
            return;
        }

        Shared = shared;
    }
}

/// <summary>
/// ChildB - inherits from Parent (TPH inheritance).
/// </summary>
public class ChildB : Parent
{
    public SharedType Shared { get; private set; }

    public void SetSharedType(SharedType shared)
    {
        if (shared == null)
            throw new ArgumentNullException(nameof(shared));

        if (Shared == shared)
        {
            return;
        }

        Shared = shared;
    }
}

/// <summary>
/// SharedType - owned entity with enum and bool properties.
/// </summary>
public class SharedType
{
    // Protected parameterless constructor for EF Core
    protected SharedType()
    {
    }

    // Private constructor
    private SharedType(EnumValue enumValue, bool isBool)
    {
        EnumValue = enumValue;
        IsBool = isBool;
    }

    public EnumValue EnumValue { get; private set; }
    public bool IsBool { get; private set; }

    // Static factory method
    public static SharedType Create(EnumValue enumValue, bool isBool)
    {
        return new SharedType(enumValue, isBool);
    }
}

// ============================================================================
// DATA CONFIGURATIONS
// ============================================================================

/// <summary>
/// Configuration for Parent with TPH discriminator.
/// </summary>
public class ParentConfiguration : IEntityTypeConfiguration<Parent>
{
    public void Configure(EntityTypeBuilder<Parent> builder)
    {
        builder.ToTable("SharedType", "THPTest");

        builder.HasKey(x => x.Id);
        builder.Property(x => x.Id)
               .HasColumnName("ChildId");

        // TPH Discriminator - same as real project
        builder.HasDiscriminator<string>("ChildType")
               .HasValue<ChildA>(nameof(ChildA))
               .HasValue<ChildB>(nameof(ChildB));
    }
}

/// <summary>
/// Configuration for ChildA.
/// </summary>
public class ChildAConfiguration : IEntityTypeConfiguration<ChildA>
{
    public void Configure(EntityTypeBuilder<ChildA> builder)
    {
        // Level 1: Parent owns SharedType
        builder.OwnsOne(p => p.Shared, cb =>
        {
            cb.Property(p => p.IsBool)
              .HasColumnName("Shared_IsBool");

            cb.Property(p => p.EnumValue)
              .HasConversion<string>()
              .HasColumnName("Shared_EnumValue");
        });
    }
}

/// <summary>
/// Configuration for ChildB.
/// </summary>
public class ChildBConfiguration : IEntityTypeConfiguration<ChildB>
{
    public void Configure(EntityTypeBuilder<ChildB> builder)
    {
        // Level 1: Parent owns SharedType
        builder.OwnsOne(p => p.Shared, cb =>
        {
            cb.Property(p => p.IsBool)
              .HasColumnName("Shared_IsBool");

            cb.Property(p => p.EnumValue)
              .HasConversion<string>()
              .HasColumnName("Shared_EnumValue");
        });
    }
}

/// <summary>
/// DbContext for testing TPH inheritance with owned entities.
/// </summary>
public class UserContext : DbContext
{
    public DbSet<Parent> Parents { get; set; } = null!;

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder
            .UseSqlServer(Environment.GetEnvironmentVariable("Test__SqlServer__DefaultConnection"))
            .LogTo(Console.WriteLine, Microsoft.Extensions.Logging.LogLevel.Information)
            .EnableSensitiveDataLogging();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Apply configuration classes
        // Order matters: Base first, then derived types
        modelBuilder.ApplyConfiguration(new ParentConfiguration());
        modelBuilder.ApplyConfiguration(new ChildAConfiguration());
        modelBuilder.ApplyConfiguration(new ChildBConfiguration());

        base.OnModelCreating(modelBuilder);
    }
}

// ============================================================================
// TEST FLOW
// ============================================================================

/// <summary>
/// Mirrors the *shape* of the production flow:
/// - create child instance (Shared starts NULL in DB)
/// - load via DbSet
/// - call SetSharedType
/// - verify DB state via EF query
/// </summary>
public sealed class ApplicationSyncFlow
{
    public async Task RunSingleCaseAsync()
    {
        int childId;

        // Step 1: Create ChildA instance.
        {
            await using var context = new UserContext();

            var childA = new ChildA();

            context.Parents.Add(childA);
            Console.WriteLine("=== Step 1: INSERT - ChildA (Shared = null) ===");
            await context.SaveChangesAsync();
            childId = childA.Id;
        }

        // Step 2: Load and set SharedType.
        Console.WriteLine("\n=== Step 2: UPDATE - Load ChildA, then set SharedType ===");
        {
            await using var context = new UserContext();

            var childA = await context.Parents
                .OfType<ChildA>()
                .SingleAsync(r => r.Id == childId);

            Console.WriteLine($"  Loaded ChildA.Id: {childA.Id}");
            Console.WriteLine($"  ChildA Type: {childA.GetType().Name}");
            Console.WriteLine($"  Shared is null: {childA.Shared == null}");

            // Build SharedType: owned entity + Set method.
            // Set EnumValue = Unknown, IsBool = false. all is default value.
            var sharedType = SharedType.Create(
                enumValue: EnumValue.Unknown,
                isBool: false);

            childA.SetSharedType(sharedType);

            // ⚠️ WORKAROUND: Explicitly mark owned entity as modified
            // Without this, EF Core 8 won't detect the change from null → defaults
            // context.Entry(childA)
            //        .Reference(c => c.Shared)
            //        .TargetEntry!
            //        .State = EntityState.Modified;

            await context.SaveChangesAsync();
        }

        // Step 3: Verify EF query.
        Console.WriteLine("\n=== Step 3: Verify DB state after UPDATE using EF Core query ===");
        {
            await using var context = new UserContext();

            var childA = await context.Parents
                .OfType<ChildA>()
                .SingleAsync(r => r.Id == childId);

            var shared = childA?.Shared;

            var efEnumValue = shared?.EnumValue;
            var efIsBool = shared?.IsBool;

            Console.WriteLine($"  EF Core - EnumValue: {efEnumValue} (expected: Unknown)");
            Console.WriteLine($"  EF Core - IsBool: {efIsBool} (expected: False)");
        }

        Console.WriteLine("\n=== Test Complete ===");
    }
}

[Tyf0x]

Just following-up to make sure the above repro case is properly demonstrating the issue so it can be acknowledged?

[roji]

@AndriySvyryd assigning to you, this does look pretty similar/related to #27509.

[Tyf0x]

Hi @AndriySvyryd,

Here is an even more simplified repro based on this previous answer (note that contrary to my previous statement, EF code-first also exhibits the issue, as demonstrated below):

Minimal repro

using Microsoft.EntityFrameworkCore;

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

var childA = new ChildA();
context.Parents.Add(childA);
await context.SaveChangesAsync();
var childId = childA.Id;

context.ChangeTracker.Clear();

var loaded = await context.Parents.OfType<ChildA>().SingleAsync(c => c.Id == childId);
loaded.SetShared(SharedType.Create(EnumValue.Unknown, false));

await context.SaveChangesAsync();

context.ChangeTracker.Clear();

var verified = await context.Parents.OfType<ChildA>().SingleAsync(c => c.Id == childId);
Console.WriteLine($"EnumValue: {verified.Shared?.EnumValue} (expected: Pass)");
Console.WriteLine($"IsBool: {verified.Shared?.IsBool} (expected: True)");

public abstract class Parent
{
    public int Id { get; set; }
}

public class ChildA : Parent
{
    public SharedType Shared { get; private set; }

    public void SetShared(SharedType shared)
    {
        Shared = shared ?? throw new ArgumentNullException(nameof(shared));
    }
}

public class ChildB : Parent
{
    public SharedType Shared { get; private set; }

    public void SetShared(SharedType shared)
    {
        Shared = shared ?? throw new ArgumentNullException(nameof(shared));
    }
}

public class SharedType
{
    protected SharedType()
    {
    }

    private SharedType(EnumValue enumValue, bool isBool)
    {
        EnumValue = enumValue;
        IsBool = isBool;
    }

    public EnumValue EnumValue { get; private set; }
    public bool IsBool { get; private set; }

    public static SharedType Create(EnumValue enumValue, bool isBool)
        => new(enumValue, isBool);
}

public enum EnumValue
{
    Unknown,
    Pass,
    Fail
}

public class BlogContext : DbContext
{
    public DbSet<Parent> Parents => Set<Parent>();

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder
            .UseSqlServer(Environment.GetEnvironmentVariable("Test__SqlServer__DefaultConnection"))
            .LogTo(Console.WriteLine, Microsoft.Extensions.Logging.LogLevel.Information)
            .EnableSensitiveDataLogging();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Parent>()
            .HasDiscriminator<string>("ChildType")
            .HasValue<ChildA>("ChildA")
            .HasValue<ChildB>("ChildB");

        modelBuilder.Entity<ChildA>().OwnsOne(c => c.Shared, sb =>
        {
            sb.Property(s => s.EnumValue).HasConversion<string>().HasColumnName("Shared_EnumValue");
            sb.Property(s => s.IsBool).HasConversion<string>().HasColumnName("Shared_IsBool");
        });

        modelBuilder.Entity<ChildB>().OwnsOne(c => c.Shared, sb =>
        {
            sb.Property(s => s.EnumValue).HasConversion<string>().HasColumnName("Shared_EnumValue");
            sb.Property(s => s.IsBool).HasConversion<string>().HasColumnName("Shared_IsBool");
        });
    }
}

The main difference is that we are specifying .HasColumnName() on all Owned Type properties so that different entity types can re-use the same columns:

Which generates the following table structure:

Important

Without specifying the column names:

EF generates 4 columns (2 per entity type) and the issue doesn't seem to happen:

Note: the generated column names are a bit confusing as it's not easy to know which column is for which entity at a glance, when looking at the DB table column names.

[Tyf0x]

Hi @AndriySvyryd ,

This is unfortunately blocking our migration up from EF core 7 which is EOL.

Given the minimal repro case above, is this confirmed to be a bug?

Thank you :)