Handle complex types in GetDatabaseValues

src/EFCore/ChangeTracking/Internal/ArrayPropertyValues.cs

@@ -99,7 +99,7 @@ public override void SetValues(PropertyValues propertyValues)
 
         for (var i = 0; i < _values.Length; i++)
         {
-            SetValue(i, propertyValues[Properties[i].Name]);
+            SetValue(i, propertyValues[Properties[i]]);
         }
     }
 
@@ -110,7 +110,7 @@ public override void SetValues(PropertyValues propertyValues)
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
     public override IReadOnlyList<IProperty> Properties
-        => _properties ??= EntityType.GetProperties().ToList();
+        => _properties ??= EntityType.GetFlattenedProperties().ToList();
 
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

src/EFCore/ChangeTracking/Internal/EntryPropertyValues.cs

@@ -94,7 +94,7 @@ public override void SetValues(PropertyValues propertyValues)
 
         foreach (var property in Properties)
         {
-            SetValueInternal(property, propertyValues[property.Name]);
+            SetValueInternal(property, propertyValues[property]);
         }
     }
 
@@ -107,7 +107,7 @@ public override void SetValues(PropertyValues propertyValues)
     public override IReadOnlyList<IProperty> Properties
     {
         [DebuggerStepThrough]
-        get => _properties ??= EntityType.GetProperties().ToList();
+        get => _properties ??= EntityType.GetFlattenedProperties().ToList();
     }
 
     /// <summary>

src/EFCore/Internal/EntityFinder.cs

@@ -855,15 +855,32 @@ private static Expression<Func<object, object[]>> BuildProjection(IEntityType en
         var entityParameter = Expression.Parameter(typeof(object), "e");
 
         var projections = new List<Expression>();
-        foreach (var property in entityType.GetProperties())
+        foreach (var property in entityType.GetFlattenedProperties())
         {
+            var path = new List<IPropertyBase> { property };
+            while (path[^1].DeclaringType is IComplexType complexType)
+            {
+                path.Add(complexType.ComplexProperty);
+            }
+
+            Expression instanceExpression = entityParameter;
+            for (var i = path.Count - 1; i >= 0; i--)
+            {
+                instanceExpression = Expression.Call(
+                    EF.PropertyMethod.MakeGenericMethod(path[i].ClrType),
+                    instanceExpression,
+                    Expression.Constant(path[i].Name, typeof(string)));
+
+                if (i != 0 && instanceExpression.Type.IsValueType)
+                {
+                    instanceExpression = Expression.Convert(instanceExpression, typeof(object));
+                }
+            }
+
             projections.Add(
                 Expression.Convert(
                     Expression.Convert(
-                        Expression.Call(
-                            EF.PropertyMethod.MakeGenericMethod(property.ClrType),
-                            entityParameter,
-                            Expression.Constant(property.Name, typeof(string))),
+                        instanceExpression,
                         property.ClrType),
                     typeof(object)));
         }

src/EFCore/Metadata/Internal/EntityTypeExtensions.cs

@@ -309,7 +309,7 @@ public static IProperty CheckPropertyBelongsToType(
     {
         Check.NotNull(property, nameof(property));
 
-        if ((property.DeclaringType as IEntityType)?.IsAssignableFrom(entityType) != true)
+        if (!property.DeclaringType.ContainingEntityType.IsAssignableFrom(entityType))
         {
             throw new InvalidOperationException(
                 CoreStrings.PropertyDoesNotBelong(property.Name, property.DeclaringType.DisplayName(), entityType.DisplayName()));

src/EFCore/Query/Internal/EntityMaterializerSource.cs

@@ -108,15 +108,16 @@ public Expression CreateMaterializeExpression(
 
         var constructorExpression = constructorBinding.CreateConstructorExpression(bindingInfo);
 
-        if (_materializationInterceptor == null)
+        if (_materializationInterceptor == null
+            // TODO: This currently applies the materialization interceptor only on the root structural type - any contained complex types
+            // don't get intercepted.
+            || structuralType is not IEntityType)
         {
             return properties.Count == 0 && blockExpressions.Count == 0
                 ? constructorExpression
                 : CreateMaterializeExpression(blockExpressions, instanceVariable, constructorExpression, properties, bindingInfo);
         }
 
-        // TODO: This currently applies the materialization interceptor only on the root structural type - any contained complex types
-        // don't get intercepted.
         return CreateInterceptionMaterializeExpression(
             structuralType,
             properties,

test/EFCore.InMemory.FunctionalTests/PropertyValuesInMemoryTest.cs

@@ -5,12 +5,44 @@ namespace Microsoft.EntityFrameworkCore;
 
 public class PropertyValuesInMemoryTest(PropertyValuesInMemoryTest.PropertyValuesInMemoryFixture fixture) : PropertyValuesTestBase<PropertyValuesInMemoryTest.PropertyValuesInMemoryFixture>(fixture)
 {
+    public override Task Complex_current_values_can_be_accessed_as_a_property_dictionary_using_IProperty()
+        => Assert.ThrowsAsync<NullReferenceException>( // In-memory database cannot query complex types
+            () => base.Complex_current_values_can_be_accessed_as_a_property_dictionary_using_IProperty());
+
+    public override Task Complex_original_values_can_be_accessed_as_a_property_dictionary_using_IProperty()
+        => Assert.ThrowsAsync<NullReferenceException>( // In-memory database cannot query complex types
+            () => base.Complex_original_values_can_be_accessed_as_a_property_dictionary_using_IProperty());
+
+    public override Task Complex_store_values_can_be_accessed_as_a_property_dictionary_using_IProperty()
+        => Assert.ThrowsAsync<NullReferenceException>( // In-memory database cannot query complex types
+            () => base.Complex_store_values_can_be_accessed_as_a_property_dictionary_using_IProperty());
+
+    public override Task Complex_store_values_can_be_accessed_asynchronously_as_a_property_dictionary_using_IProperty()
+        => Assert.ThrowsAsync<NullReferenceException>( // In-memory database cannot query complex types
+            () => base.Complex_store_values_can_be_accessed_asynchronously_as_a_property_dictionary_using_IProperty());
+
     public class PropertyValuesInMemoryFixture : PropertyValuesFixtureBase
     {
         public override DbContextOptionsBuilder AddOptions(DbContextOptionsBuilder builder)
-            => base.AddOptions(builder).EnableSensitiveDataLogging(false);
+            => base.AddOptions(builder)
+                .ConfigureWarnings(w => w.Ignore(CoreEventId.MappedComplexPropertyIgnoredWarning))
+                .EnableSensitiveDataLogging(false);
 
         protected override ITestStoreFactory TestStoreFactory
             => InMemoryTestStoreFactory.Instance;
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder, DbContext context)
+        {
+            base.OnModelCreating(modelBuilder, context);
+
+            // In-memory database doesn't support complex type queries
+            modelBuilder.Entity<Building>(
+                b =>
+                {
+                    b.Ignore(e => e.Culture);
+                    b.Ignore(e => e.Milk);
+                });
+
+        }
     }
 }