Fix to #26451 - Temporal Table: Owned Entities support

Added extensibility point to SharedTypeEntityExpandingExpressionVisitor so that we can create temporal table expressions representing owned entities, if their owner is also a temporal table expression.
Just like any other nav expansion, this only works for AsOf operation.

src/EFCore.Relational/Infrastructure/EntityFrameworkRelationalServicesBuilder.cs

@@ -81,6 +81,7 @@ public static readonly IDictionary<Type, ServiceCharacteristics> RelationalServi
  { typeof(ISqlExpressionFactory), new ServiceCharacteristics(ServiceLifetime.Scoped) },
  { typeof(IRelationalQueryStringFactory), new ServiceCharacteristics(ServiceLifetime.Scoped) },
  { typeof(IRelationalParameterBasedSqlProcessorFactory), new ServiceCharacteristics(ServiceLifetime.Scoped) },
+ { typeof(IRelationalSharedTypeEntityExpansionHelper), new ServiceCharacteristics(ServiceLifetime.Scoped) },
  { typeof(IMigrationsModelDiffer), new ServiceCharacteristics(ServiceLifetime.Scoped) },
  { typeof(IMigrationsSqlGenerator), new ServiceCharacteristics(ServiceLifetime.Scoped) },
  { typeof(IMigrator), new ServiceCharacteristics(ServiceLifetime.Scoped) },
@@ -192,6 +193,7 @@ public override EntityFrameworkServicesBuilder TryAddCoreServices()
  TryAdd<IRelationalParameterBasedSqlProcessorFactory, RelationalParameterBasedSqlProcessorFactory>();
  TryAdd<IRelationalQueryStringFactory, RelationalQueryStringFactory>();
  TryAdd<IQueryCompilationContextFactory, RelationalQueryCompilationContextFactory>();
+ TryAdd<IRelationalSharedTypeEntityExpansionHelper, RelationalSharedTypeEntityExpansionHelper>();
 
  ServiceCollectionMap.GetInfrastructure()
  .AddDependencySingleton<RelationalSqlGenerationHelperDependencies>()
@@ -227,7 +229,8 @@ public override EntityFrameworkServicesBuilder TryAddCoreServices()
  .AddDependencyScoped<RelationalConnectionDependencies>()
  .AddDependencyScoped<RelationalDatabaseDependencies>()
  .AddDependencyScoped<RelationalQueryContextDependencies>()
- .AddDependencyScoped<RelationalQueryCompilationContextDependencies>();
+ .AddDependencyScoped<RelationalQueryCompilationContextDependencies>()
+ .AddDependencyScoped<RelationalSharedTypeEntityExpansionHelperDependencies>();
 
  return base.TryAddCoreServices();
  }

src/EFCore.Relational/Query/IRelationalSharedTypeEntityExpansionHelper.cs

@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Microsoft.EntityFrameworkCore.Query
+{
+ /// <summary>
+ /// Service which helps with various aspects of shared type entity expansion extensibility for relational providrers.
+ /// </summary>
+ /// <para>
+ /// The service lifetime is <see cref="ServiceLifetime.Scoped" />. This means that each
+ /// <see cref="DbContext" /> instance will use its own instance of this service.
+ /// The implementation may depend on other services registered with any lifetime.
+ /// The implementation does not need to be thread-safe.
+ /// </para>
+ /// <remarks>
+ /// See <see href="https://aka.ms/efcore-docs-providers">Implementation of database providers and extensions</see>
+ /// and <see href="https://aka.ms/efcore-how-queries-work">How EF Core queries work</see> for more information.
+ /// </remarks>
+ public interface IRelationalSharedTypeEntityExpansionHelper
+ {
+ /// <summary>
+ /// Creates a SelectExpression representing owned type.
+ /// </summary>
+ public SelectExpression CreateInnerSelectExpression(
+ TableExpressionBase sourceTable,
+ IEntityType targetEntityType);
+ }
+}

src/EFCore.Relational/Query/RelationalQueryableMethodTranslatingExpressionVisitor.cs

@@ -50,7 +50,10 @@ public RelationalQueryableMethodTranslatingExpressionVisitor(
  _queryCompilationContext = queryCompilationContext;
  _sqlTranslator = relationalDependencies.RelationalSqlTranslatingExpressionVisitorFactory.Create(queryCompilationContext, this);
  _sharedTypeEntityExpandingExpressionVisitor =
- new SharedTypeEntityExpandingExpressionVisitor(_sqlTranslator, sqlExpressionFactory);
+ new SharedTypeEntityExpandingExpressionVisitor(
+ _sqlTranslator,
+ sqlExpressionFactory,
+ relationalDependencies.RelationalSharedTypeEntityExpansionHelper);
  _projectionBindingExpressionVisitor = new RelationalProjectionBindingExpressionVisitor(this, _sqlTranslator);
  _sqlExpressionFactory = sqlExpressionFactory;
  _subquery = false;
@@ -74,7 +77,11 @@ protected RelationalQueryableMethodTranslatingExpressionVisitor(
  _sqlTranslator = RelationalDependencies.RelationalSqlTranslatingExpressionVisitorFactory.Create(
  parentVisitor._queryCompilationContext, parentVisitor);
  _sharedTypeEntityExpandingExpressionVisitor =
- new SharedTypeEntityExpandingExpressionVisitor(_sqlTranslator, parentVisitor._sqlExpressionFactory);
+ new SharedTypeEntityExpandingExpressionVisitor(
+ _sqlTranslator,
+ parentVisitor._sqlExpressionFactory,
+ RelationalDependencies.RelationalSharedTypeEntityExpansionHelper);
+
  _projectionBindingExpressionVisitor = new RelationalProjectionBindingExpressionVisitor(this, _sqlTranslator);
  _sqlExpressionFactory = parentVisitor._sqlExpressionFactory;
  _subquery = true;
@@ -1144,15 +1151,18 @@ private static readonly MethodInfo _objectEqualsMethodInfo
 
  private readonly RelationalSqlTranslatingExpressionVisitor _sqlTranslator;
  private readonly ISqlExpressionFactory _sqlExpressionFactory;
+ private readonly IRelationalSharedTypeEntityExpansionHelper _sharedTypeEntityExpansionHelper;
 
  private SelectExpression _selectExpression;
 
  public SharedTypeEntityExpandingExpressionVisitor(
  RelationalSqlTranslatingExpressionVisitor sqlTranslator,
- ISqlExpressionFactory sqlExpressionFactory)
+ ISqlExpressionFactory sqlExpressionFactory,
+ IRelationalSharedTypeEntityExpansionHelper sharedTypeEntityExpansionHelper)
  {
  _sqlTranslator = sqlTranslator;
  _sqlExpressionFactory = sqlExpressionFactory;
+ _sharedTypeEntityExpansionHelper = sharedTypeEntityExpansionHelper;
  _selectExpression = null!;
  }
 
@@ -1341,7 +1351,20 @@ outerKey is NewArrayExpression newArrayExpression
  // Owned types don't support inheritance See https://github.com/dotnet/efcore/issues/9630
  // So there is no handling for dependent having TPT
  table = targetEntityType.GetViewOrTableMappings().Single().Table;
- var innerSelectExpression = _sqlExpressionFactory.Select(targetEntityType);
+
+ // just need any column - we use it only to extract the table it originated from
+ var sourceColumn = entityProjectionExpression
+ .BindProperty(
+ navigation.IsOnDependent
+ ? foreignKey.Properties[0]
+ : foreignKey.PrincipalKey.Properties[0]);
+
+ var sourceTable = FindRootTableExpressionForColumn(sourceColumn.Table, sourceColumn.Name);
+
+ var innerSelectExpression = _sharedTypeEntityExpansionHelper.CreateInnerSelectExpression(
+ sourceTable,
+ targetEntityType);
+
  var innerShapedQuery = CreateShapedQueryExpression(targetEntityType, innerSelectExpression);
 
  var makeNullable = foreignKey.PrincipalKey.Properties
@@ -1375,6 +1398,27 @@ outerKey is NewArrayExpression newArrayExpression
  }
 
  return innerShaper;
+
+ TableExpressionBase FindRootTableExpressionForColumn(TableExpressionBase table, string columnName)
+ {
+ if (table is JoinExpressionBase joinExpressionBase)
+ {
+ table = joinExpressionBase.Table;
+ }
+ else if (table is SetOperationBase setOperationBase)
+ {
+ table = setOperationBase.Source1;
+ }
+
+ if (table is SelectExpression selectExpression)
+ {
+ var matchingProjection = (ColumnExpression)selectExpression.Projection.Where(p => p.Alias == columnName).Single().Expression;
+
+ return FindRootTableExpressionForColumn(matchingProjection.Table, matchingProjection.Name);
+ }
+
+ return table;
+ }
  }
 
  private static Expression AddConvertToObject(Expression expression)

src/EFCore.Relational/Query/RelationalQueryableMethodTranslatingExpressionVisitorDependencies.cs

@@ -54,13 +54,16 @@ public sealed record RelationalQueryableMethodTranslatingExpressionVisitorDepend
  [EntityFrameworkInternal]
  public RelationalQueryableMethodTranslatingExpressionVisitorDependencies(
  IRelationalSqlTranslatingExpressionVisitorFactory relationalSqlTranslatingExpressionVisitorFactory,
- ISqlExpressionFactory sqlExpressionFactory)
+ ISqlExpressionFactory sqlExpressionFactory,
+ IRelationalSharedTypeEntityExpansionHelper relationalSharedTypeEntityExpansionHelper)
  {
  Check.NotNull(relationalSqlTranslatingExpressionVisitorFactory, nameof(relationalSqlTranslatingExpressionVisitorFactory));
  Check.NotNull(sqlExpressionFactory, nameof(sqlExpressionFactory));
+ Check.NotNull(relationalSharedTypeEntityExpansionHelper, nameof(relationalSharedTypeEntityExpansionHelper));
 
  RelationalSqlTranslatingExpressionVisitorFactory = relationalSqlTranslatingExpressionVisitorFactory;
  SqlExpressionFactory = sqlExpressionFactory;
+ RelationalSharedTypeEntityExpansionHelper = relationalSharedTypeEntityExpansionHelper;
  }
 
  /// <summary>
@@ -72,5 +75,10 @@ public RelationalQueryableMethodTranslatingExpressionVisitorDependencies(
  /// The SQL expression factory.
  /// </summary>
  public ISqlExpressionFactory SqlExpressionFactory { get; init; }
+
+ /// <summary>
+ /// Shared type entity expansion helper.
+ /// </summary>
+ public IRelationalSharedTypeEntityExpansionHelper RelationalSharedTypeEntityExpansionHelper { get; init; }
  }
 }

src/EFCore.Relational/Query/RelationalSharedTypeEntityExpansionHelper.cs

@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
+
+namespace Microsoft.EntityFrameworkCore.Query
+{
+ /// <inheritdoc/>
+ public class RelationalSharedTypeEntityExpansionHelper : IRelationalSharedTypeEntityExpansionHelper
+ {
+ /// <summary>
+ /// Creates a new instance of the <see cref="RelationalSharedTypeEntityExpansionHelper" /> class.
+ /// </summary>
+ /// <param name="dependencies">Dependencies for this service.</param>
+ public RelationalSharedTypeEntityExpansionHelper(RelationalSharedTypeEntityExpansionHelperDependencies dependencies)
+ {
+ Dependencies = dependencies;
+ }
+
+ /// <summary>
+ /// Dependencies for this service.
+ /// </summary>
+ protected virtual RelationalSharedTypeEntityExpansionHelperDependencies Dependencies { get; }
+
+ /// <inheritdoc/>
+ public virtual SelectExpression CreateInnerSelectExpression(
+ TableExpressionBase sourceTable,
+ IEntityType targetEntityType)
+ => Dependencies.SqlExpressionFactory.Select(targetEntityType);
+ }
+}

src/EFCore.Relational/Query/RelationalSharedTypeEntityExpansionHelperDependencies.cs

@@ -0,0 +1,67 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Utilities;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Microsoft.EntityFrameworkCore.Query
+{
+ /// <summary>
+ /// <para>
+ /// Service dependencies parameter class for <see cref="RelationalSharedTypeEntityExpansionHelper" />
+ /// </para>
+ /// <para>
+ /// This type is typically used by database providers (and other extensions). It is generally
+ /// not used in application code.
+ /// </para>
+ /// <para>
+ /// Do not construct instances of this class directly from either provider or application code as the
+ /// constructor signature may change as new dependencies are added. Instead, use this type in
+ /// your constructor so that an instance will be created and injected automatically by the
+ /// dependency injection container. To create an instance with some dependent services replaced,
+ /// first resolve the object from the dependency injection container, then replace selected
+ /// services using the 'With...' methods. Do not call the constructor at any point in this process.
+ /// </para>
+ /// <para>
+ /// The service lifetime is <see cref="ServiceLifetime.Scoped" />. This means that each
+ /// <see cref="DbContext" /> instance will use its own instance of this service.
+ /// The implementation may depend on other services registered with any lifetime.
+ /// The implementation does not need to be thread-safe.
+ /// </para>
+ /// </summary>
+ public sealed record RelationalSharedTypeEntityExpansionHelperDependencies
+ {
+ /// <summary>
+ /// <para>
+ /// Creates the service dependencies parameter object for a <see cref="RelationalQueryableMethodTranslatingExpressionVisitor" />.
+ /// </para>
+ /// <para>
+ /// Do not call this constructor directly from either provider or application code as it may change
+ /// as new dependencies are added. Instead, use this type in your constructor so that an instance
+ /// will be created and injected automatically by the dependency injection container. To create
+ /// an instance with some dependent services replaced, first resolve the object from the dependency
+ /// injection container, then replace selected services using the 'With...' methods. Do not call
+ /// the constructor at any point in this process.
+ /// </para>
+ /// <para>
+ /// 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.
+ /// </para>
+ /// </summary>
+ [EntityFrameworkInternal]
+ public RelationalSharedTypeEntityExpansionHelperDependencies(ISqlExpressionFactory sqlExpressionFactory)
+ {
+ Check.NotNull(sqlExpressionFactory, nameof(sqlExpressionFactory));
+
+ SqlExpressionFactory = sqlExpressionFactory;
+ }
+
+ /// <summary>
+ /// The SQL expression factory.
+ /// </summary>
+ public ISqlExpressionFactory SqlExpressionFactory { get; init; }
+ }
+}

src/EFCore.SqlServer/Extensions/SqlServerServiceCollectionExtensions.cs

@@ -142,6 +142,7 @@ public static IServiceCollection AddEntityFrameworkSqlServer(this IServiceCollec
  .TryAdd<IRelationalParameterBasedSqlProcessorFactory, SqlServerParameterBasedSqlProcessorFactory>()
  .TryAdd<INavigationExpansionExtensibilityHelper, SqlServerNavigationExpansionExtensibilityHelper>()
  .TryAdd<IQueryableMethodTranslatingExpressionVisitorFactory, SqlServerQueryableMethodTranslatingExpressionVisitorFactory>()
+ .TryAdd<IRelationalSharedTypeEntityExpansionHelper, SqlServerSharedTypeEntityExpansionHelper>()
  .TryAddProviderSpecificServices(
  b => b
  .TryAddSingleton<ISqlServerValueGeneratorCache, SqlServerValueGeneratorCache>()

src/EFCore.SqlServer/Properties/SqlServerStrings.resx

@@ -325,6 +325,9 @@
  <data name="TemporalSetOperationOnMismatchedSources" xml:space="preserve">
  <value>Set operation can't be applied on entity '{entityType}' because temporal operations on both arguments don't match.</value>
  </data>
+ <data name="TemporalOwnedTypeMappedToDifferentTableOnlySupportedForAsOf" xml:space="preserve">
+ <value>Only '{operationName}' temporal operation is supported for entitiy that owns another entity which is mapped different table.</value>
+ </data>
  <data name="TransientExceptionDetected" xml:space="preserve">
  <value>An exception has been raised that is likely due to a transient failure. Consider enabling transient error resiliency by adding 'EnableRetryOnFailure' to the 'UseSqlServer' call.</value>
  </data>