Fix to #26469 - Query: enable temporal tables for table splitting sce…

…narios

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.

Also added internal interface to TableExpression, so that we can extract table metadata information (table name and schema) from provider specific table expressions.

Relaxed validation for table splitting entities mapped to temporal table - they are ok as long as their period columns are consistent.

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,39 @@
+// 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 <see cref="TableExpressionBase" /> related to the source table for a given entity type.
+        /// </summary>
+        public TableExpressionBase CreateRelatedTableExpression(
+            TableExpressionBase sourceTable,
+            IEntityType targetEntityType);
+
+        ///// <summary>
+        ///// Creates a SelectExpression representing owned type.
+        ///// </summary>
+        //public SelectExpression CreateInnerSelectExpression(
+        //    TableExpressionBase sourceTable,
+        //    IEntityType targetEntityType);
+    }
+}

src/EFCore.Relational/Query/Internal/ITableMetadata.cs

@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.EntityFrameworkCore.Query.Internal
+{
+    /// <summary>
+    ///     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.
+    /// </summary>
+    public interface ITableMetadata
+    {
+        /// <summary>
+        ///     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.
+        /// </summary>
+        string Name { get; }
+
+        /// <summary>
+        ///     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.
+        /// </summary>
+        string? Schema { get; }
+    }
+}

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;
@@ -1157,15 +1164,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!;
             }
 
@@ -1255,11 +1265,33 @@ protected override Expression VisitExtension(Expression extensionExpression)
                     return null;
                 }
 
+                var entityProjectionExpression = (EntityProjectionExpression)
+                    (entityShaperExpression.ValueBufferExpression is ProjectionBindingExpression projectionBindingExpression
+                        ? _selectExpression.GetProjection(projectionBindingExpression)
+                        : entityShaperExpression.ValueBufferExpression);
+
+                var useOldBehavior = AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue26469", out var enabled)
+                    && enabled;
+
                 var foreignKey = navigation.ForeignKey;
                 if (navigation.IsCollection)
                 {
-                    var innerShapedQuery = CreateShapedQueryExpression(
-                        targetEntityType, _sqlExpressionFactory.Select(targetEntityType));
+                    var innerShapedQuery = default(ShapedQueryExpression);
+                    if (!useOldBehavior)
+                    {
+                        var innerSelectExpression = BuildInnerSelectExpressionForOwnedTypeMappedToDifferentTable(
+                        entityProjectionExpression,
+                        navigation,
+                        foreignKey,
+                        targetEntityType);
+
+                        innerShapedQuery = CreateShapedQueryExpression(targetEntityType, innerSelectExpression);
+                    }
+                    else
+                    {
+                        innerShapedQuery = CreateShapedQueryExpression(
+                            targetEntityType, _sqlExpressionFactory.Select(targetEntityType));
+                    }
 
                     var makeNullable = foreignKey.PrincipalKey.Properties
                         .Concat(foreignKey.Properties)
@@ -1307,11 +1339,6 @@ outerKey is NewArrayExpression newArrayExpression
                         Expression.Quote(correlationPredicate));
                 }
 
-                var entityProjectionExpression = (EntityProjectionExpression)
-                    (entityShaperExpression.ValueBufferExpression is ProjectionBindingExpression projectionBindingExpression
-                        ? _selectExpression.GetProjection(projectionBindingExpression)
-                        : entityShaperExpression.ValueBufferExpression);
-
                 var innerShaper = entityProjectionExpression.BindNavigation(navigation);
                 if (innerShaper == null)
                 {
@@ -1354,7 +1381,21 @@ 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);
+
+                        var innerSelectExpression = default(SelectExpression);
+                        if (!useOldBehavior)
+                        {
+                            innerSelectExpression = BuildInnerSelectExpressionForOwnedTypeMappedToDifferentTable(
+                                entityProjectionExpression,
+                                navigation,
+                                foreignKey,
+                                targetEntityType);
+                        }
+                        else
+                        {
+                            innerSelectExpression = _sqlExpressionFactory.Select(targetEntityType);
+                        }
+
                         var innerShapedQuery = CreateShapedQueryExpression(targetEntityType, innerSelectExpression);
 
                         var makeNullable = foreignKey.PrincipalKey.Properties
@@ -1380,14 +1421,65 @@ outerKey is NewArrayExpression newArrayExpression
                         innerShaper = new RelationalEntityShaperExpression(
                             targetEntityType,
                             _selectExpression.GenerateWeakEntityProjectionExpression(
-                                targetEntityType, table, null, leftJoinTable, nullable: true)!,
+                                targetEntityType,
+                                table,
+                                null,
+                                leftJoinTable,
+                                nullable: true)!,
                             nullable: true);
                     }
 
                     entityProjectionExpression.AddNavigationBinding(navigation, innerShaper);
                 }
 
                 return innerShaper;
+
+                SelectExpression BuildInnerSelectExpressionForOwnedTypeMappedToDifferentTable(
+                    EntityProjectionExpression entityProjectionExpression,
+                    INavigation navigation,
+                    IForeignKey foreignKey,
+                    IEntityType 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 ownedTable = _sharedTypeEntityExpansionHelper.CreateRelatedTableExpression(
+                        sourceTable,
+                        targetEntityType);
+
+                    return _sqlExpressionFactory.Select(targetEntityType, ownedTable);
+
+                    //return _sharedTypeEntityExpansionHelper.CreateInnerSelectExpression(
+                    //    sourceTable,
+                    //    targetEntityType);
+                }
+
+                static 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,17 @@ 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 +76,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,47 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Linq;
+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 TableExpressionBase CreateRelatedTableExpression(
+            TableExpressionBase sourceTable,
+            IEntityType targetEntityType)
+        {
+            var table = targetEntityType.GetTableMappings().Single().Table;
+
+            return new TableExpression(table);
+
+            //Dependencies.SqlExpressionFactory.Select(targetEntityType)
+
+            //throw new System.NotImplementedException();
+        }
+
+        ///// <inheritdoc/>
+        //public virtual SelectExpression CreateInnerSelectExpression(
+        //    TableExpressionBase sourceTable,
+        //    IEntityType targetEntityType)
+        //    => Dependencies.SqlExpressionFactory.Select(targetEntityType);
+    }
+}