Query: Improve logic to find column names in TPC

src/EFCore.Relational/Query/SqlExpressions/SelectExpression.cs

@@ -224,18 +224,17 @@ internal SelectExpression(IEntityType entityType, ISqlExpressionFactory sqlExpre
  var tables = entityTypes.Select(e => GetTableBase(e)).ToArray();
  var properties = GetAllPropertiesInHierarchy(entityType).ToArray();
  var propertyNamesMap = new Dictionary<IProperty, string>();
- foreach (var property in entityTypes[0].GetProperties())
- {
- propertyNamesMap[property] = tables[0].FindColumn(property)!.Name;
- }
- for (var i = 1; i < entityTypes.Length; i++)
+ for (var i = 0; i < entityTypes.Length; i++)
  {
- foreach (var property in entityTypes[i].GetDeclaredProperties())
+ foreach (var property in entityTypes[i].GetProperties())
  {
- Check.DebugAssert(!propertyNamesMap.ContainsKey(property), "Duplicate property found.");
- propertyNamesMap[property] = tables[i].FindColumn(property)!.Name;
+ if (!propertyNamesMap.ContainsKey(property))
+ {
+ propertyNamesMap[property] = tables[i].FindColumn(property)!.Name;
+ }
  }
  }
+
  var propertyNames = new string[properties.Length];
  for (var i = 0; i < properties.Length; i++)
  {

test/EFCore.Relational.Specification.Tests/Query/SimpleQueryRelationalTestBase.cs

@@ -101,6 +101,36 @@ protected class MyEntity
  public DateTime SomeDate { get; set; }
  public static DateTime Modify(DateTime date) => throw new NotSupportedException();
  }
+
+ [ConditionalTheory]
+ [MemberData(nameof(IsAsyncData))]
+ public virtual Task Hierarchy_query_with_abstract_type_sibling_TPC(bool async)
+ {
+ return Hierarchy_query_with_abstract_type_sibling_helper(async,
+ mb =>
+ {
+ mb.Entity<Animal>().UseTpcMappingStrategy();
+ mb.Entity<Pet>().ToTable("Pets");
+ mb.Entity<Cat>().ToTable("Cats");
+ mb.Entity<Dog>().ToTable("Dogs");
+ mb.Entity<FarmAnimal>().ToTable("FarmAnimals");
+ });
+ }
+
+ [ConditionalTheory]
+ [MemberData(nameof(IsAsyncData))]
+ public virtual Task Hierarchy_query_with_abstract_type_sibling_TPT(bool async)
+ {
+ return Hierarchy_query_with_abstract_type_sibling_helper(async,
+ mb =>
+ {
+ mb.Entity<Animal>().UseTptMappingStrategy();
+ mb.Entity<Pet>().ToTable("Pets");
+ mb.Entity<Cat>().ToTable("Cats");
+ mb.Entity<Dog>().ToTable("Dogs");
+ mb.Entity<FarmAnimal>().ToTable("FarmAnimals");
+ });
+ }
  }
 }
 

test/EFCore.Specification.Tests/Query/SimpleQueryTestBase.cs

@@ -1256,4 +1256,80 @@ protected class SearchResult
  public int RowId { get; set; }
  public string DistinctValue { get; set; }
  }
+
+ [ConditionalTheory]
+ [MemberData(nameof(IsAsyncData))]
+ public virtual Task Hierarchy_query_with_abstract_type_sibling(bool async)
+ {
+ return Hierarchy_query_with_abstract_type_sibling_helper(async, null);
+ }
+
+ public virtual async Task Hierarchy_query_with_abstract_type_sibling_helper(bool async, Action<ModelBuilder> onModelCreating)
+ {
+ var contextFactory = await InitializeAsync<Context28196>(onModelCreating: onModelCreating, seed: c => c.Seed());
+ using var context = contextFactory.CreateContext();
+
+ var query = context.Animals.OfType<Pet>().Where(a => a.Species.StartsWith("F"));
+
+ var result = async
+ ? await query.ToListAsync()
+ : query.ToList();
+ }
+
+ protected class Context28196 : DbContext
+ {
+ public Context28196(DbContextOptions options)
+ : base(options)
+ {
+ }
+
+ public DbSet<Animal> Animals { get; set; }
+
+ protected override void OnModelCreating(ModelBuilder modelBuilder)
+ {
+ modelBuilder.Entity<Animal>().Property(e => e.Id).ValueGeneratedNever();
+ modelBuilder.Entity<Pet>();
+ modelBuilder.Entity<Cat>();
+ modelBuilder.Entity<Dog>();
+ modelBuilder.Entity<FarmAnimal>();
+ }
+
+ public void Seed()
+ {
+ AddRange(
+ new Cat { Id = 1, Name = "Alice", Species = "Felis catus", EdcuationLevel = "MBA" },
+ new Cat { Id = 2, Name = "Mac", Species = "Felis catus", EdcuationLevel = "BA" },
+ new Dog { Id = 3, Name = "Toast", Species = "Canis familiaris", FavoriteToy = "Mr. Squirrel" },
+ new FarmAnimal { Id = 4, Value = 100.0, Species = "Ovis aries" });
+
+ SaveChanges();
+ }
+ }
+
+ protected abstract class Animal
+ {
+ public int Id { get; set; }
+ public string Species { get; set; }
+ }
+
+ protected class FarmAnimal : Animal
+ {
+ public double Value { get; set; }
+ }
+
+ protected abstract class Pet : Animal
+ {
+ public string Name { get; set; }
+ }
+
+ protected class Cat : Pet
+ {
+ public string EdcuationLevel { get; set; }
+ }
+
+ protected class Dog : Pet
+ {
+ public string FavoriteToy { get; set; }
+ }
+
 }

test/EFCore.SqlServer.FunctionalTests/Query/SimpleQuerySqlServerTest.cs

@@ -429,4 +429,46 @@ HAVING COUNT(*) = 1
 WHERE [t].[TableId] = 123
 ORDER BY [t].[ParcelNumber]");
  }
+
+ public override async Task Hierarchy_query_with_abstract_type_sibling(bool async)
+ {
+ await base.Hierarchy_query_with_abstract_type_sibling(async);
+
+ AssertSql(
+ @"SELECT [a].[Id], [a].[Discriminator], [a].[Species], [a].[Name], [a].[EdcuationLevel], [a].[FavoriteToy]
+FROM [Animals] AS [a]
+WHERE [a].[Discriminator] IN (N'Cat', N'Dog') AND [a].[Species] IS NOT NULL AND ([a].[Species] LIKE N'F%')");
+ }
+
+ public override async Task Hierarchy_query_with_abstract_type_sibling_TPT(bool async)
+ {
+ await base.Hierarchy_query_with_abstract_type_sibling_TPT(async);
+
+ AssertSql(
+ @"SELECT [a].[Id], [a].[Species], [p].[Name], [c].[EdcuationLevel], [d].[FavoriteToy], CASE
+ WHEN [d].[Id] IS NOT NULL THEN N'Dog'
+ WHEN [c].[Id] IS NOT NULL THEN N'Cat'
+END AS [Discriminator]
+FROM [Animals] AS [a]
+LEFT JOIN [Pets] AS [p] ON [a].[Id] = [p].[Id]
+LEFT JOIN [Cats] AS [c] ON [a].[Id] = [c].[Id]
+LEFT JOIN [Dogs] AS [d] ON [a].[Id] = [d].[Id]
+WHERE ([d].[Id] IS NOT NULL OR [c].[Id] IS NOT NULL) AND [a].[Species] IS NOT NULL AND ([a].[Species] LIKE N'F%')");
+ }
+
+ public override async Task Hierarchy_query_with_abstract_type_sibling_TPC(bool async)
+ {
+ await base.Hierarchy_query_with_abstract_type_sibling_TPC(async);
+
+ AssertSql(
+ @"SELECT [t].[Id], [t].[Species], [t].[Name], [t].[EdcuationLevel], [t].[FavoriteToy], [t].[Discriminator]
+FROM (
+ SELECT [c].[Id], [c].[Species], [c].[Name], [c].[EdcuationLevel], NULL AS [FavoriteToy], N'Cat' AS [Discriminator]
+ FROM [Cats] AS [c]
+ UNION ALL
+ SELECT [d].[Id], [d].[Species], [d].[Name], NULL AS [EdcuationLevel], [d].[FavoriteToy], N'Dog' AS [Discriminator]
+ FROM [Dogs] AS [d]
+) AS [t]
+WHERE [t].[Species] IS NOT NULL AND ([t].[Species] LIKE N'F%')");
+ }
 }