Temp tables and table hints are handled differently, so that all limitations regarding SplittingBehavior and OwnedTypes are lifted.

Author: PawelGerr

src/Thinktecture.EntityFrameworkCore.BulkOperations/EntityFrameworkCore/Query/BulkOperationOptimizingVisitor.cs

@@ -23,7 +23,7 @@ public sealed class TempTableExpression : TableExpressionBase, INotNullableSqlEx
    /// </summary>
    /// <param name="name">The name of the temp table.</param>
    /// <param name="alias">The alias of the temp table.</param>
-   public TempTableExpression(string name, string alias)
+   public TempTableExpression(string name, string? alias)
       : base(alias)
    {
       Name = name;

src/Thinktecture.EntityFrameworkCore.BulkOperations/EntityFrameworkCore/Query/SqlExpressions/TempTableExpression.cs

@@ -0,0 +1,32 @@
+using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
+using Thinktecture.EntityFrameworkCore.Query;
+using Thinktecture.EntityFrameworkCore.Query.SqlExpressions;
+
+namespace Thinktecture.EntityFrameworkCore.TempTables;
+
+/// <summary>
+/// For internal use only.
+/// </summary>
+public class TempTableTableMetadataProcessor : ITableMetadataProcessor
+{
+   /// <summary>
+   /// Singleton.
+   /// </summary>
+   public static readonly TempTableTableMetadataProcessor Instance = new();
+
+   /// <summary>
+   /// For internal use only.
+   /// </summary>
+   public int Order => 10;
+
+   /// <summary>
+   /// For internal use only.
+   /// </summary>
+   public TableExpressionBase ProcessMetadata(TableExpressionBase expression, TableWithMetadata tableWithMetadata)
+   {
+      if (tableWithMetadata.Metadata.TryGetValue(nameof(TempTableExpression), out var value) && value is string tempTableName)
+         return new TempTableExpression(tempTableName, expression.Alias);
+
+      return expression;
+   }
+}

src/Thinktecture.EntityFrameworkCore.BulkOperations/EntityFrameworkCore/TempTables/TempTableQueryContext.cs

@@ -5,7 +5,6 @@
 using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
 using Microsoft.EntityFrameworkCore.Storage;
 using Thinktecture.EntityFrameworkCore.Query.SqlExpressions;
-using Thinktecture.EntityFrameworkCore.TempTables;
 using Thinktecture.Internal;
 
 // ReSharper disable once CheckNamespace
@@ -22,8 +21,6 @@ public static class BulkOperationsRelationalQueryableMethodTranslatingExpression
    /// <param name="visitor">The visitor.</param>
    /// <param name="methodCallExpression">Method call to translate.</param>
    /// <param name="typeMappingSource">Type mapping source.</param>
-   /// <param name="queryCompilationContext">Query compilation context.</param>
-   /// <param name="tempTableQueryContextFactory"></param>
    /// <param name="sqlExpressionFactory">SQL expression factory.</param>
    /// <returns>Translated method call if a custom method is found; otherwise <c>null</c>.</returns>
    /// <exception cref="ArgumentNullException">
@@ -33,8 +30,6 @@ public static class BulkOperationsRelationalQueryableMethodTranslatingExpression
       this RelationalQueryableMethodTranslatingExpressionVisitor visitor,
       MethodCallExpression methodCallExpression,
       IRelationalTypeMappingSource typeMappingSource,
-      QueryCompilationContext queryCompilationContext,
-      TempTableQueryContextFactory tempTableQueryContextFactory,
       ISqlExpressionFactory sqlExpressionFactory)
    {
       ArgumentNullException.ThrowIfNull(visitor);
@@ -53,13 +48,9 @@ public static class BulkOperationsRelationalQueryableMethodTranslatingExpression
          if (methodCallExpression.Method.Name == nameof(BulkOperationsDbSetExtensions.FromTempTable))
          {
             var tempTableInfo = ((TempTableInfoExpression)methodCallExpression.Arguments[1]).Value;
-
-            if (!tempTableInfo.HasOwnedEntities)
-               return CreateShapedQueryExpressionForTempTable(sqlExpressionFactory, tempTableInfo);
-
             var shapedQueryExpression = GetShapedQueryExpression(visitor, methodCallExpression);
 
-            return TranslateFromTempTable(shapedQueryExpression, tempTableInfo, queryCompilationContext, tempTableQueryContextFactory);
+            return TranslateFromTempTable(shapedQueryExpression, tempTableInfo);
          }
 
          throw new InvalidOperationException(CoreStrings.TranslationFailed(methodCallExpression.Print()));
@@ -70,32 +61,14 @@ public static class BulkOperationsRelationalQueryableMethodTranslatingExpression
 
    private static Expression TranslateFromTempTable(
       ShapedQueryExpression shapedQueryExpression,
-      TempTableInfo tempTableInfo,
-      QueryCompilationContext queryCompilationContext,
-      TempTableQueryContextFactory tempTableQueryContextFactory)
+      TempTableInfo tempTableInfo)
    {
       var tempTableName = tempTableInfo.Name ?? throw new Exception("No temp table name provided.");
-      var selectExpression = (SelectExpression)shapedQueryExpression.QueryExpression;
-      var tableExpression = (TableExpression)selectExpression.Tables.Single();
 
-      var ctx = tempTableQueryContextFactory.Create(tableExpression, tempTableName ?? throw new Exception("No temp table name provided."));
-      var extractor = Expression.Lambda<Func<QueryContext, TempTableQueryContext>>(Expression.Constant(ctx), QueryCompilationContext.QueryContextParameter);
-
-      queryCompilationContext.RegisterRuntimeParameter(ctx.ParameterName, extractor);
-
-      return shapedQueryExpression;
-   }
-
-   private static Expression CreateShapedQueryExpressionForTempTable(ISqlExpressionFactory sqlExpressionFactory, TempTableInfo tempTableInfo)
-   {
-      var tempTableName = tempTableInfo.Name ?? throw new Exception("No temp table name provided.");
-      var tempTableExpression = new TempTableExpression(tempTableName, "#");
-      var selectExpression = sqlExpressionFactory.Select(tempTableInfo.EntityType, tempTableExpression);
+      var selectExpression = (SelectExpression)shapedQueryExpression.QueryExpression;
+      var newSelectExpression = selectExpression.AddTableMetadata(nameof(TempTableExpression), _ => tempTableName);
 
-      return new ShapedQueryExpression(selectExpression,
-                                       new RelationalEntityShaperExpression(tempTableInfo.EntityType,
-                                                                            new ProjectionBindingExpression(selectExpression, new ProjectionMember(), typeof(ValueBuffer)),
-                                                                            false));
+      return shapedQueryExpression.Update(newSelectExpression, shapedQueryExpression.ShaperExpression);
    }
 
    private static Expression TranslateBulkDelete(ShapedQueryExpression shapedQueryExpression, IRelationalTypeMappingSource typeMappingSource)

src/Thinktecture.EntityFrameworkCore.BulkOperations/EntityFrameworkCore/TempTables/TempTableQueryContextFactory.cs

@@ -1,11 +1,7 @@
-using Microsoft.EntityFrameworkCore.Metadata;
-
 namespace Thinktecture.Internal;
 
 /// <summary>
 /// Temp table infos.
 /// </summary>
 /// <param name="Name">The name of the temp table.</param>
-/// <param name="HasOwnedEntities">Indication whether the temp table has owned entities.</param>
-/// <param name="EntityType">The entity type of the temp table.</param>
-public record TempTableInfo(string Name, bool HasOwnedEntities, IEntityType EntityType);
+public record TempTableInfo(string Name);

src/Thinktecture.EntityFrameworkCore.BulkOperations/EntityFrameworkCore/TempTables/TempTableTableMetadataProcessor.cs

@@ -80,6 +80,9 @@ public bool UseThinktectureRelationalQueryContextFactory
 
    internal List<ConventionToRemove> ConventionsToRemove { get; }
 
+   private readonly List<ITableMetadataProcessor> _metadataProcessors;
+   internal IReadOnlyList<ITableMetadataProcessor> MetadataProcessors => _metadataProcessors;
+
    /// <summary>
    /// Initializes new instance of <see cref="RelationalDbContextOptionsExtension"/>.
    /// </summary>
@@ -88,6 +91,7 @@ public RelationalDbContextOptionsExtension()
       _serviceDescriptors = new List<ServiceDescriptor>();
       _evaluatableExpressionFilterPlugins = new List<Type>();
       ConventionsToRemove = new List<ConventionToRemove>();
+      _metadataProcessors = new List<ITableMetadataProcessor> { TableHintsTableMetadataProcessor.Instance };
       _stringBuilderPolicy = new StringBuilderPooledObjectPolicy
                              {
                                 InitialCapacity = _DEFAULT_INITIAL_CAPACITY,
@@ -103,6 +107,8 @@ public void ApplyServices(IServiceCollection services)
       services.TryAddSingleton<RelationalDbContextOptionsExtensionOptions>();
       services.AddSingleton<ISingletonOptions>(provider => provider.GetRequiredService<RelationalDbContextOptionsExtensionOptions>());
 
+      services.AddSingleton<RelationalOptimizingVisitor>();
+
       services.Add<IConventionSetPlugin, RelationalConventionSetPlugin>(GetLifetime<IConventionSetPlugin>());
 
       services.TryAddSingleton<ITenantDatabaseProviderFactory>(DummyTenantDatabaseProviderFactory.Instance);
@@ -157,6 +163,20 @@ public void Validate(IDbContextOptions options)
          throw new InvalidOperationException($"TenantDatabaseSupport is enabled but there is no registration of an implementation of '{nameof(ITenantDatabaseProviderFactory)}'.");
    }
 
+   /// <summary>
+   /// Adds <paramref name="tableMetadataProcessor"/>.
+   /// </summary>
+   /// <param name="tableMetadataProcessor">Table metadata processor.</param>
+   public RelationalDbContextOptionsExtension AddTableMetadataProcessor(ITableMetadataProcessor tableMetadataProcessor)
+   {
+      ArgumentNullException.ThrowIfNull(tableMetadataProcessor);
+
+      if (!_metadataProcessors.Contains(tableMetadataProcessor))
+         _metadataProcessors.Add(tableMetadataProcessor);
+
+      return this;
+   }
+
    /// <summary>
    /// Removes convention of type <paramref name="implementationTypeToRemove"/> from the current convention set.
    /// </summary>

src/Thinktecture.EntityFrameworkCore.BulkOperations/Extensions/BulkOperationsRelationalQueryableMethodTranslatingExpressionVisitorExtensions.cs

@@ -1,5 +1,6 @@
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Thinktecture.EntityFrameworkCore.Conventions;
+using Thinktecture.EntityFrameworkCore.Query;
 using Thinktecture.EntityFrameworkCore.Query.ExpressionTranslators;
 
 namespace Thinktecture.EntityFrameworkCore.Infrastructure;
@@ -21,6 +22,8 @@ public class RelationalDbContextOptionsExtensionOptions : ISingletonOptions
 
    internal IReadOnlyList<ConventionToRemove> ConventionsToRemove { get; private set; } = Array.Empty<ConventionToRemove>();
 
+   internal IReadOnlyList<ITableMetadataProcessor> MetadataProcessors { get; private set; } = Array.Empty<ITableMetadataProcessor>();
+
    /// <inheritdoc />
    public void Initialize(IDbContextOptions options)
    {
@@ -29,6 +32,7 @@ public void Initialize(IDbContextOptions options)
       RowNumberSupportEnabled = extension.AddRowNumberSupport;
       TenantDatabaseSupportEnabled = extension.AddTenantDatabaseSupport;
       ConventionsToRemove = extension.ConventionsToRemove.ToList();
+      MetadataProcessors = extension.MetadataProcessors.ToList();
    }
 
    /// <inheritdoc />
@@ -44,16 +48,30 @@ public void Validate(IDbContextOptions options)
 
       if (!Equal(extension.ConventionsToRemove, ConventionsToRemove))
          throw new InvalidOperationException($"The setting '{nameof(RelationalDbContextOptionsExtension.ConventionsToRemove)}' has been changed.");
+
+      if (!Equal(extension.MetadataProcessors, MetadataProcessors))
+         throw new InvalidOperationException($"The setting '{nameof(RelationalDbContextOptionsExtension.MetadataProcessors)}' has been changed.");
    }
 
-   private bool Equal(IReadOnlyList<ConventionToRemove> conventionsToRemove, IReadOnlyList<ConventionToRemove> other)
+   private bool Equal<T>(IReadOnlyList<T> collection, IReadOnlyList<T> otherCollection)
    {
-      if (conventionsToRemove.Count != other.Count)
+      if (collection.Count != otherCollection.Count)
          return false;
 
       for (var i = 0; i < ConventionsToRemove.Count; i++)
       {
-         if (!conventionsToRemove[i].Equals(other[i]))
+         var item = collection[i];
+         var other = otherCollection[i];
+
+         if (item is null)
+         {
+            if (other is null)
+               continue;
+
+            return false;
+         }
+
+         if (!item.Equals(other))
             return false;
       }
 

src/Thinktecture.EntityFrameworkCore.BulkOperations/Extensions/Internal/TempTableInfo.cs

@@ -0,0 +1,19 @@
+using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
+
+namespace Thinktecture.EntityFrameworkCore.Query;
+
+/// <summary>
+/// For internal use only.
+/// </summary>
+public interface ITableMetadataProcessor
+{
+   /// <summary>
+   /// For internal use only.
+   /// </summary>
+   int Order { get; }
+
+   /// <summary>
+   /// For internal use only.
+   /// </summary>
+   TableExpressionBase ProcessMetadata(TableExpressionBase expression, TableWithMetadata tableWithMetadata);
+}