Optional dependent null

src/EFCore.Relational/Diagnostics/RelationalLoggerExtensions.cs

@@ -2964,5 +2964,32 @@ public static void BatchExecutorFailedToReleaseSavepoint(
                 diagnostics.DispatchEventData(definition, eventData, diagnosticSourceEnabled, simpleLogEnabled);
             }
         }
+
+        /// <summary>
+        ///     Logs the <see cref="RelationalEventId.OptionalDependentWithoutIdentifyingPropertyWarning" /> event.
+        /// </summary>
+        /// <param name="diagnostics"> The diagnostics logger to use. </param>
+        /// <param name="entityType"> The entity type. </param>
+        public static void OptionalDependentWithAllNullPropertiesWarning(
+            this IDiagnosticsLogger<DbLoggerCategory.Update> diagnostics,
+            IEntityType entityType)
+        {
+            var definition = RelationalResources.LogOptionalDependentWithoutIdentifyingProperty(diagnostics);
+
+            if (diagnostics.ShouldLog(definition))
+            {
+                definition.Log(diagnostics, entityType.DisplayName());
+            }
+
+            if (diagnostics.NeedsEventData(definition, out var diagnosticSourceEnabled, out var simpleLogEnabled))
+            {
+                var eventData = new EntityTypeEventData(
+                    definition,
+                    OptionalDependentWithoutIdentifyingPropertyWarning,
+                    entityType);
+
+                diagnostics.DispatchEventData(definition, eventData, diagnosticSourceEnabled, simpleLogEnabled);
+            }
+        }
     }
 }

src/EFCore.Relational/Update/Internal/CommandBatchPreparer.cs

@@ -201,6 +201,14 @@ protected virtual IEnumerable<ModificationCommand> CreateModificationCommands(
                             entry,
                             (n, s, c) => new ModificationCommand(n, s, generateParameterName, _sensitiveLoggingEnabled, c));
                         isMainEntry = sharedCommandsMap.IsMainEntry(entry);
+
+                        if (!isMainEntry)
+                        {
+                            if(sharedCommandsMap.IsOptionalWithNull(entry))
+                            {
+                                Dependencies.UpdateLogger.OptionalDependentWithAllNullPropertiesWarning(entry.EntityType);
+                            }
+                        }
                     }
                     else
                     {

src/EFCore.Relational/Update/Internal/SharedTableEntryMap.cs

@@ -74,6 +74,57 @@ public virtual TValue GetOrAddValue(IUpdateEntry entry, SharedTableEntryValueFac
         public virtual bool IsMainEntry(IUpdateEntry entry)
             => !_table.GetRowInternalForeignKeys(entry.EntityType).Any();
 
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     any release. You should only use it directly in your code with extreme caution and knowing that
+        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+        /// </summary>
+        public virtual bool IsOptionalWithNull(IUpdateEntry entry)
+        {
+            var principalEntityTypesMap = new Dictionary<IEntityType, bool>();
+
+            var optional = GetPrincipalEntityTypes(entry.EntityType);
+
+            var nullableWithNull = true;
+
+            if (!optional)
+            {
+                return false;
+            }
+
+            foreach (var property in entry.EntityType.GetProperties())
+            {
+                if (property.IsPrimaryKey())
+                {
+                    continue;
+                }
+
+                if(entry.GetCurrentValue(property) is not null)
+                {
+                    nullableWithNull = false;
+                }
+            }
+
+            bool GetPrincipalEntityTypes(IEntityType entityType)
+            {
+                if (!principalEntityTypesMap.TryGetValue(entityType, out var optional))
+                {
+                    foreach (var foreignKey in entityType.FindForeignKeys(entityType.FindPrimaryKey()!.Properties))
+                    {
+                        var principalEntityType = foreignKey.PrincipalEntityType;
+                        var innerOptional = GetPrincipalEntityTypes(principalEntityType.GetRootType());
+
+                        optional |= !foreignKey.IsRequiredDependent | innerOptional;
+                    }
+                }
+
+                return optional;
+            }
+
+            return nullableWithNull;
+        }
+
         private IUpdateEntry GetMainEntry(IUpdateEntry entry)
         {
             var entityType = entry.EntityType;

test/EFCore.Relational.Specification.Tests/TableSplittingTestBase.cs

@@ -4,6 +4,9 @@
 using System;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using Microsoft.EntityFrameworkCore.Diagnostics.Internal;
+using Microsoft.EntityFrameworkCore.TestModels.QueryModel;
 using Microsoft.EntityFrameworkCore.TestModels.TransportationModel;
 using Microsoft.EntityFrameworkCore.TestUtilities;
 using Xunit;
@@ -548,10 +551,92 @@ public virtual async Task Optional_dependent_materialized_when_no_properties()
             }
         }
 
+        [ConditionalFact]
+        public virtual async Task Warn_when_save_optional_dependent_with_null_values()
+        {
+            await InitializeSharedAsync(
+                modelBuilder =>
+                {
+                    modelBuilder.Entity<MeterReadingDetail>(
+                        dob =>
+                        {
+                            dob.ToTable("MeterReadings");
+                            dob.Property(o => o.ReadingStatus).HasColumnName("ReadingStatus");
+                        });
+
+                    modelBuilder.Entity<MeterReading>(
+                        ob =>
+                        {
+                            ob.ToTable("MeterReadings");
+                            ob.Property(o => o.ReadingStatus).HasColumnName("ReadingStatus");
+                            ob.HasOne(o => o.MeterReadingDetails).WithOne()
+                                .HasForeignKey<MeterReadingDetail>(o => o.Id);
+                        });
+                }, seed: false
+                );
+
+            using var context = CreateSharedContext();
+            var scooterEntry = context.Add(
+                new MeterReading
+                {
+                    MeterReadingDetails = new MeterReadingDetail()
+                });
+
+            var expected = RelationalResources.LogOptionalDependentWithoutIdentifyingProperty(new TestLogger<TestRelationalLoggingDefinitions>()).GenerateMessage(nameof(MeterReadingDetail));
+
+            context.SaveChanges();
+
+            var log = TestSqlLoggerFactory.Log.Single(l => l.Level == Extensions.Logging.LogLevel.Warning);
+
+            Assert.Equal(expected, log.Message);
+        }
+
+        [ConditionalFact]
+        public virtual async Task No_warn_when_save_optional_dependent_at_least_one_non_null()
+        {
+            await InitializeSharedAsync(
+                modelBuilder =>
+                {
+                    modelBuilder.Entity<MeterReadingDetail>(
+                        dob =>
+                        {
+                            dob.ToTable("MeterReadings");
+                            dob.Property(o => o.ReadingStatus).HasColumnName("ReadingStatus");
+                        });
+
+                    modelBuilder.Entity<MeterReading>(
+                        ob =>
+                        {
+                            ob.ToTable("MeterReadings");
+                            ob.Property(o => o.ReadingStatus).HasColumnName("ReadingStatus");
+                            ob.HasOne(o => o.MeterReadingDetails).WithOne()
+                                .HasForeignKey<MeterReadingDetail>(o => o.Id);
+                        });
+                }, seed: false
+                );
+
+            using var context = CreateSharedContext();
+            var scooterEntry = context.Add(
+                new MeterReading
+                {
+                    MeterReadingDetails = new MeterReadingDetail()
+                    {
+                        CurrentRead = "123"
+                    }
+                });
+
+            context.SaveChanges();
+
+            var log = TestSqlLoggerFactory.Log.SingleOrDefault(l => l.Level == Extensions.Logging.LogLevel.Warning);
+
+            Assert.Null(log.Message);
+        }
+
         protected override string StoreName { get; } = "TableSplittingTest";
         protected TestSqlLoggerFactory TestSqlLoggerFactory
             => (TestSqlLoggerFactory)ListLoggerFactory;
         protected ContextFactory<TransportationContext> ContextFactory { get; private set; }
+        protected ContextFactory<SharedTableContext> SharedContextFactory { get; private set; }
 
         protected void AssertSql(params string[] expected)
             => TestSqlLoggerFactory.AssertBaseline(expected);
@@ -580,14 +665,27 @@ protected async Task InitializeAsync(Action<ModelBuilder> onModelCreating, bool
                 onModelCreating, shouldLogCategory: _ => true, seed: seed ? c => c.Seed() : null);
         }
 
+        protected async Task InitializeSharedAsync(Action<ModelBuilder> onModelCreating, bool seed = true)
+        {
+            SharedContextFactory = await InitializeAsync<SharedTableContext>(
+                onModelCreating,
+                shouldLogCategory: _ => true,
+                onConfiguring: options => options.ConfigureWarnings(w => w.Log(RelationalEventId.OptionalDependentWithoutIdentifyingPropertyWarning)
+                ));
+        }
+
         protected virtual TransportationContext CreateContext()
             => ContextFactory.CreateContext();
 
+        protected virtual SharedTableContext CreateSharedContext()
+            => SharedContextFactory.CreateContext();
+
         public override void Dispose()
         {
             base.Dispose();
 
             ContextFactory = null;
+            SharedContextFactory = null;
         }
     }
 }

test/EFCore.Specification.Tests/TestModels/QueryModel/MeterReading.cs

@@ -0,0 +1,12 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.EntityFrameworkCore.TestModels.QueryModel
+{
+    public class MeterReading
+    {
+        public int Id { get; set; }
+        public MeterReadingStatus? ReadingStatus { get; set; }
+        public MeterReadingDetail MeterReadingDetails { get; set; }
+    }
+}

test/EFCore.Specification.Tests/TestModels/QueryModel/MeterReadingDetail.cs

@@ -0,0 +1,13 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.EntityFrameworkCore.TestModels.QueryModel
+{
+    public class MeterReadingDetail
+    {
+        public int Id { get; set; }
+        public MeterReadingStatus? ReadingStatus { get; set; }
+        public string CurrentRead { get; set; }
+        public string PreviousRead { get; set; }
+    }
+}

test/EFCore.Specification.Tests/TestModels/QueryModel/MeterReadingStatus.cs

@@ -0,0 +1,11 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.EntityFrameworkCore.TestModels.QueryModel
+{
+    public enum MeterReadingStatus
+    {
+        Running=0,
+        NotAccesible=2
+    }
+}

test/EFCore.Specification.Tests/TestModels/QueryModel/SharedTableContext.cs

@@ -0,0 +1,19 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.EntityFrameworkCore.TestUtilities;
+
+
+namespace Microsoft.EntityFrameworkCore.TestModels.QueryModel
+{
+    public class SharedTableContext : PoolableDbContext
+    {
+        public SharedTableContext(DbContextOptions options)
+            : base(options)
+        {
+        }
+
+        public DbSet<MeterReading> MeterReadings { get; set; }
+        public DbSet<MeterReadingDetail> MeterReadingDetails { get; set; }
+    }
+}