Materialization condition for optional dependents with all null properties but having own optional dependent

[smitpatel]

Using 5.0 preview6
Repro code:

using System;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace EFSampleApp
{
    public class Program
    {
        public static async Task Main(string[] args)
        {
            using (var db = new MyContext())
            {
                // Recreate database
                db.Database.EnsureDeleted();
                db.Database.EnsureCreated();

                // Seed database
                db.Add(new Vehicle
                {
                    VehicleName = "Car",
                    Operator = new Operator
                    {
                        OperatorDetails = new OperatorDetails
                        {
                            Details = "Dull"
                        }
                    }
                });

                db.SaveChanges();
            }

            using (var db = new MyContext())
            {
                // Run queries
                var query = db.Set<Vehicle>().Include(e => e.Operator.OperatorDetails).First();

                Console.WriteLine(query.VehicleName);
                Console.WriteLine(query.Operator);
                Console.WriteLine(query.Operator.OperatorName);
                Console.WriteLine(query.Operator.OperatorDetails);
                Console.WriteLine(query.Operator.OperatorDetails.Details);
            }
            Console.WriteLine("Program finished.");
        }
    }


    public class MyContext : DbContext
    {
        private static ILoggerFactory ContextLoggerFactory
            => LoggerFactory.Create(b =>
            {
                b
                .AddConsole()
                .AddFilter("", LogLevel.Debug);
            });

        // Declare DBSets
        public DbSet<Vehicle> Vehicles { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            // Select 1 provider
            optionsBuilder
                .UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=_ModelApp;Trusted_Connection=True;Connect Timeout=5;ConnectRetryCount=0")
                //.UseSqlite("filename=_modelApp.db")
                //.UseInMemoryDatabase(databaseName: "_modelApp")
                //.UseCosmos("https://localhost:8081", @"C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==", "_ModelApp")
                .EnableSensitiveDataLogging()
                .UseLoggerFactory(ContextLoggerFactory);
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            // Configure model
        }
    }

    public class Vehicle
    {
        public int Id { get; set; }
        public string VehicleName { get; set; }
        public Operator Operator { get; set; }
    }

    [Table("Vehicles")]
    public class Operator
    {
        public int Id { get; set; }
        public string OperatorName { get; set; }
        [ForeignKey("Id")]
        public Vehicle Vehicle { get; set; }
        public OperatorDetails OperatorDetails { get; set; }
    }

    [Table("Vehicles")]
    public class OperatorDetails
    {
        public int Id { get; set; }
        public string Details { get; set; }
        [ForeignKey("Id")]
        public Operator Operator { get; set; }
    }
}

We generate following SQL,

      SELECT TOP(1) [v].[Id], [v].[VehicleName], [t1].[Id], [t1].[OperatorName], [t5].[Id], [t5].[Details]
      FROM [Vehicles] AS [v]
      LEFT JOIN (
          SELECT [t0].[Id], [t0].[OperatorName], [v3].[Id] AS [Id0]
          FROM (
              SELECT [v0].[Id], [v0].[OperatorName]
              FROM [Vehicles] AS [v0]
              WHERE [v0].[OperatorName] IS NOT NULL
              UNION
              SELECT [v1].[Id], [v1].[OperatorName]
              FROM [Vehicles] AS [v1]
              INNER JOIN (
                  SELECT [v2].[Id], [v2].[Details]
                  FROM [Vehicles] AS [v2]
                  WHERE [v2].[Details] IS NOT NULL
              ) AS [t] ON [v1].[Id] = [t].[Id]
          ) AS [t0]
          INNER JOIN [Vehicles] AS [v3] ON [t0].[Id] = [v3].[Id]
      ) AS [t1] ON [v].[Id] = [t1].[Id]
      LEFT JOIN (
          SELECT [v4].[Id], [v4].[Details], [t4].[Id] AS [Id0], [t4].[Id0] AS [Id00]
          FROM [Vehicles] AS [v4]
          INNER JOIN (
              SELECT [t3].[Id], [t3].[OperatorName], [v8].[Id] AS [Id0]
              FROM (
                  SELECT [v5].[Id], [v5].[OperatorName]
                  FROM [Vehicles] AS [v5]
                  WHERE [v5].[OperatorName] IS NOT NULL
                  UNION
                  SELECT [v6].[Id], [v6].[OperatorName]
                  FROM [Vehicles] AS [v6]
                  INNER JOIN (
                      SELECT [v7].[Id], [v7].[Details]
                      FROM [Vehicles] AS [v7]
                      WHERE [v7].[Details] IS NOT NULL
                  ) AS [t2] ON [v6].[Id] = [t2].[Id]
              ) AS [t3]
              INNER JOIN [Vehicles] AS [v8] ON [t3].[Id] = [v8].[Id]
          ) AS [t4] ON [v4].[Id] = [t4].[Id]
          WHERE [v4].[Details] IS NOT NULL
      ) AS [t5] ON [t1].[Id] = [t5].[Id]

Issue: Vehicle -> Operator -> OperatorDetails are sharing table here. All the non-pk properties of Operator are nullable.
While generating SQL we generate Union with the dependents (to include operators which have associated OperatorDetails) regardless of values in Operator columns. But when we are materializing we don't have that information. We only have ValueBuffer associated with Operator and which has PK with non-null value and rest is null values. PK is expected to non-null due to table splitting. Hence we don't materialize the instance and above throws null ref.

[smitpatel]

We decided that we are going to throw for this scenario and user must add a required property in the middle dependent which can serve as identifying property to determine materialization.

[scottk4106]

We decided that we are going to throw for this scenario and user must add a required property in the middle dependent which can serve as identifying property to determine materialization.

Just looking for a little more detail. Does this mean that if this situation occurs, an exception will be thrown rather than not returning the data expected?

To add a required property as suggested, can you change the Operator class and add the property Ignore, like this?

    [Table("Vehicles")]
    public class Operator
    {
        public int Id { get; set; }
        public string OperatorName { get; set; }
        [ForeignKey("Id")]
        public Vehicle Vehicle { get; set; }
        public OperatorDetails OperatorDetails { get; set; }

        public int Ignore { get; private set; } = 0;
    }