Fix nested MemberInitExpression for complex property updates in ON CONFLICT

Co-authored-by: PhenX <42170+PhenX@users.noreply.github.com>

Author: Copilot

src/PhenX.EntityFrameworkCore.BulkInsert/Dialect/SqlDialectBuilder.cs

@@ -253,9 +253,9 @@ protected IEnumerable<string> GetUpdates<T>(DbContext context, TableMetadata tab
             }
             case MemberInitExpression memberInit:
             {
-                foreach (var binding in memberInit.Bindings.OfType<MemberAssignment>())
+                foreach (var updateSql in GetUpdatesFromMemberInit<T>(context, table, memberInit, lambda))
                 {
-                    yield return $"{table.GetQuotedColumnName(binding.Member.Name)} = {ToSqlExpression<T>(context, table, binding.Expression, lambda)}";
+                    yield return updateSql;
                 }
 
                 break;
@@ -411,6 +411,38 @@ private string ToSqlExpression<TEntity>(DbContext context, TableMetadata table,
         }
     }
 
+    /// <summary>
+    /// Extracts update SQL statements from a MemberInitExpression, handling both simple properties
+    /// and nested complex property initializations.
+    /// </summary>
+    /// <param name="context">DB context</param>
+    /// <param name="table">Table metadata</param>
+    /// <param name="memberInit">The member initialization expression</param>
+    /// <param name="lambda">Current lambda expression</param>
+    /// <typeparam name="T">Entity type</typeparam>
+    /// <returns>SQL update statements for each property assignment</returns>
+    private IEnumerable<string> GetUpdatesFromMemberInit<T>(DbContext context, TableMetadata table, MemberInitExpression memberInit, LambdaExpression lambda)
+    {
+        foreach (var binding in memberInit.Bindings.OfType<MemberAssignment>())
+        {
+            // Check if the binding expression is a nested MemberInitExpression (complex property assignment)
+            if (binding.Expression is MemberInitExpression nestedMemberInit)
+            {
+                // Recursively process nested complex property assignments
+                foreach (var nestedBinding in nestedMemberInit.Bindings.OfType<MemberAssignment>())
+                {
+                    // For complex properties, the column name is the nested property name (e.g., "Code", "Name")
+                    yield return $"{table.GetQuotedColumnName(nestedBinding.Member.Name)} = {ToSqlExpression<T>(context, table, nestedBinding.Expression, lambda)}";
+                }
+            }
+            else
+            {
+                // Simple property assignment
+                yield return $"{table.GetQuotedColumnName(binding.Member.Name)} = {ToSqlExpression<T>(context, table, binding.Expression, lambda)}";
+            }
+        }
+    }
+
     /// <summary>
     /// Traverses up a member expression chain to find the root parameter expression.
     /// This handles both simple properties (e.g., excluded.Name) and complex properties (e.g., excluded.ComplexObject.Property).

tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Merge/MergeTestsBase.cs

@@ -455,4 +455,63 @@ public async Task InsertEntities_WithComplexType_UpdateWithWhere(InsertStrategy
             Assert.True(e.OwnedComplexType.Code > 100);
         });
     }
+
+    [SkippableTheory]
+    [InlineData(InsertStrategy.InsertReturn)]
+    [InlineData(InsertStrategy.InsertReturnAsync)]
+    public async Task InsertEntities_WithComplexType_UpdateComplexPropertyConditionally(InsertStrategy strategy)
+    {
+        Skip.If(_context.IsProvider(ProviderType.MySql));
+        // Oracle MERGE does not support returning entities
+        Skip.If(_context.IsProvider(ProviderType.Oracle));
+
+        // Arrange - Create entities with different Code values
+        var entities = new List<TestEntityWithComplexType>
+        {
+            new TestEntityWithComplexType
+            {
+                TestRun = _run,
+                OwnedComplexType = new OwnedObject { Code = 50, Name = "LowCode" }
+            },
+            new TestEntityWithComplexType
+            {
+                TestRun = _run,
+                OwnedComplexType = new OwnedObject { Code = 150, Name = "HighCode" }
+            }
+        };
+
+        // Act - First insert (returns entities with generated IDs)
+        var insertedEntities = await _context.InsertWithStrategyAsync(strategy, entities);
+
+        // Update both entities with new values
+        foreach (var entity in insertedEntities)
+        {
+            entity.OwnedComplexType.Code = entity.OwnedComplexType.Code + 10;
+            entity.OwnedComplexType.Name = $"Modified_{entity.OwnedComplexType.Name}";
+        }
+
+        // Act - Update using nested MemberInitExpression for complex property assignment
+        // Note: entities with Code >= 100 (original value) will not be updated due to WHERE clause
+        var updatedEntities = await _context.InsertWithStrategyAsync(strategy, insertedEntities,
+            o => o.CopyGeneratedColumns = true,
+            onConflict: new OnConflictOptions<TestEntityWithComplexType>
+            {
+                Update = (inserted, excluded) => new TestEntityWithComplexType
+                {
+                    OwnedComplexType = new OwnedObject
+                    {
+                        Code = excluded.OwnedComplexType.Code,
+                        Name = excluded.OwnedComplexType.Name
+                    }
+                },
+                Where = (inserted, excluded) => inserted.OwnedComplexType.Code < 100
+            });
+
+        // Assert - Only the entity with original Code < 100 should be updated (Code was 50, now 60)
+        // The one with original Code >= 100 is not updated but is also not returned by RETURNING clause
+        Assert.Single(updatedEntities);
+        var updatedEntity = updatedEntities.Single();
+        Assert.Equal(60, updatedEntity.OwnedComplexType.Code);
+        Assert.Equal("Modified_LowCode", updatedEntity.OwnedComplexType.Name);
+    }
 }