Build QueryRoot correctly for entity entries

Specifically for owned entities Resolves #16186 Resolves #18366
dotnet · Oct 17, 2019 · e185afc · e185afc
1 parent 75a5f2e
commit e185afc
Show file tree

Hide file tree

Showing 2 changed files with 94 additions and 11 deletions.
diff --git a/src/EFCore/Internal/EntityFinder.cs b/src/EFCore/Internal/EntityFinder.cs
@@ -321,18 +321,23 @@ private static Expression<Func<object, bool>> BuildObjectLambda(IReadOnlyList<IP
 
         private IQueryable BuildQueryRoot(IEntityType entityType)
         {
-            var definingEntityType = entityType.DefiningEntityType;
-            return definingEntityType == null
-                ? (IQueryable)_setCache.GetOrAddSet(_setSource, entityType.ClrType)
-                : BuildQueryRoot(definingEntityType, entityType);
-        }
+            if (entityType.DefiningEntityType is IEntityType definingEntityType)
+            {
+                var queryRoot = BuildQueryRoot(definingEntityType);
 
-        private IQueryable BuildQueryRoot(IEntityType definingEntityType, IEntityType entityType)
-        {
-            var queryRoot = BuildQueryRoot(definingEntityType);
+                return (IQueryable)_selectMethod.MakeGenericMethod(definingEntityType.ClrType, entityType.ClrType)
+                    .Invoke(null, new object[] { queryRoot, entityType.DefiningNavigationName });
+            }
+
+            if (entityType.FindOwnership() is IForeignKey ownership)
+            {
+                var queryRoot = BuildQueryRoot(ownership.PrincipalEntityType);
+
+                return (IQueryable)_selectMethod.MakeGenericMethod(ownership.PrincipalEntityType.ClrType, entityType.ClrType)
+                    .Invoke(null, new object[] { queryRoot, ownership.PrincipalToDependent.Name });
+            }
 
-            return (IQueryable)_selectMethod.MakeGenericMethod(definingEntityType.ClrType, entityType.ClrType)
-                .Invoke(null, new object[] { queryRoot, entityType.DefiningNavigationName });
+            return (IQueryable)_setCache.GetOrAddSet(_setSource, entityType.ClrType);
         }
 
         private static readonly MethodInfo _selectMethod

diff --git a/test/EFCore.Specification.Tests/OptimisticConcurrencyTestBase.cs b/test/EFCore.Specification.Tests/OptimisticConcurrencyTestBase.cs
@@ -456,7 +456,7 @@ public virtual Task
         [ConditionalTheory]
         [InlineData(false)]
         [InlineData(true)]
-        public virtual async Task Calling_Reload_on_an__Added_entity_that_is_not_in_database_is_no_op(bool async)
+        public virtual async Task Calling_Reload_on_an_Added_entity_that_is_not_in_database_is_no_op(bool async)
         {
             using (var c = CreateF1Context())
             {
@@ -598,6 +598,84 @@ await c.Database.CreateExecutionStrategy().ExecuteAsync(
             }
         }
 
+        [ConditionalTheory]
+        [InlineData(false)]
+        [InlineData(true)]
+        public virtual async Task Calling_GetDatabaseValues_on_owned_entity_works(bool async)
+        {
+            using (var c = CreateF1Context())
+            {
+                await c.Database.CreateExecutionStrategy().ExecuteAsync(
+                    c, async context =>
+                    {
+                        using (var transaction = context.Database.BeginTransaction())
+                        {
+                            var titleSponsor = context.Set<TitleSponsor>().Single(t => t.Name == "Vodafone");
+
+                            var ownerEntry = context.Entry(titleSponsor);
+                            var ownedEntry = ownerEntry.Reference(e => e.Details).TargetEntry;
+
+                            using (var innerContext = CreateF1Context())
+                            {
+                                UseTransaction(innerContext.Database, transaction);
+
+                                var innerTitleSponsor = innerContext.Set<TitleSponsor>().Single(t => t.Name == "Vodafone");
+                                innerTitleSponsor.Details.Days = 5;
+
+                                await innerContext.SaveChangesAsync();
+
+                                var databaseValues = async
+                                    ? await ownedEntry.GetDatabaseValuesAsync()
+                                    : ownedEntry.GetDatabaseValues();
+                                Assert.Equal(5, databaseValues.GetValue<int>("Days"));
+                            }
+                        }
+                    });
+            }
+        }
+
+        [ConditionalTheory]
+        [InlineData(false)]
+        [InlineData(true)]
+        public virtual async Task Calling_Reload_on_owned_entity_works(bool async)
+        {
+            using (var c = CreateF1Context())
+            {
+                await c.Database.CreateExecutionStrategy().ExecuteAsync(
+                    c, async context =>
+                    {
+                        using (var transaction = context.Database.BeginTransaction())
+                        {
+                            var titleSponsor = context.Set<TitleSponsor>().Single(t => t.Name == "Vodafone");
+
+                            var ownerEntry = context.Entry(titleSponsor);
+                            var ownedEntry = ownerEntry.Reference(e => e.Details).TargetEntry;
+
+                            using (var innerContext = CreateF1Context())
+                            {
+                                UseTransaction(innerContext.Database, transaction);
+
+                                var innerTitleSponsor = innerContext.Set<TitleSponsor>().Single(t => t.Name == "Vodafone");
+                                innerTitleSponsor.Details.Days = 5;
+
+                                await innerContext.SaveChangesAsync();
+
+                                if (async)
+                                {
+                                    await ownedEntry.ReloadAsync();
+                                }
+                                else
+                                {
+                                    ownedEntry.Reload();
+                                }
+
+                                Assert.Equal(5, ownedEntry.Property(e => e.Days).CurrentValue);
+                            }
+                        }
+                    });
+            }
+        }
+
         #endregion
 
         #region Helpers