TempTables for primitive types are pre-configured by a convention.

Author: PawelGerr

samples/Thinktecture.EntityFrameworkCore.Benchmarks/BenchmarkContext.cs

@@ -1,5 +1,6 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging.Abstractions;
 using Thinktecture.Database;
 
 namespace Thinktecture;
@@ -14,11 +15,18 @@ public BenchmarkContext()
 
       var services = new ServiceCollection()
                      .AddDbContext<SqliteBenchmarkDbContext>(builder => builder.UseSqlite(config.GetConnectionString("sqlite"),
-                                                                                          optionsBuilder => optionsBuilder.AddBulkOperationSupport()))
+                                                                                          optionsBuilder => optionsBuilder
+                                                                                             .AddBulkOperationSupport())
+                                                                               .UseLoggerFactory(NullLoggerFactory.Instance)
+                                                            )
                      .AddDbContext<SqlServerBenchmarkDbContext>(builder => builder.UseSqlServer(config.GetConnectionString("sqlServer"),
-                                                                                                optionsBuilder => optionsBuilder.AddBulkOperationSupport()));
+                                                                                                optionsBuilder => optionsBuilder
+                                                                                                                  .AddBulkOperationSupport()
+                                                                                                                  .AddCollectionParameterSupport())
+                                                                                  .UseLoggerFactory(NullLoggerFactory.Instance)
+                                                               );
 
-      RootServiceProvider = services.BuildServiceProvider();
+      RootServiceProvider = services.BuildServiceProvider(new ServiceProviderOptions { ValidateScopes = true, ValidateOnBuild = true });
    }
 
    private static IConfiguration GetConfiguration()

samples/Thinktecture.EntityFrameworkCore.Benchmarks/Benchmarking/ComplexCollectionParameter.cs

@@ -0,0 +1,49 @@
+using BenchmarkDotNet.Attributes;
+using Microsoft.Extensions.DependencyInjection;
+using Thinktecture.Database;
+using Thinktecture.EntityFrameworkCore.BulkOperations;
+
+namespace Thinktecture.Benchmarking;
+
+[MemoryDiagnoser]
+public class ComplexCollectionParameter : IDisposable
+{
+   private BenchmarkContext? _benchmarkContext;
+   private IServiceScope? _scope;
+   private SqlServerBenchmarkDbContext? _sqlServerDbContext;
+   private readonly SqlServerTempTableBulkInsertOptions _sqlServerOptions = new();
+
+   private readonly MyParameter[] _objects = Enumerable.Range(1, 500).Select(i => new MyParameter(Guid.NewGuid(), i.ToString())).ToArray();
+
+   [GlobalSetup]
+   public void Initialize()
+   {
+      _benchmarkContext = new BenchmarkContext();
+      _scope = _benchmarkContext.RootServiceProvider.CreateScope();
+      _sqlServerDbContext = _scope.ServiceProvider.GetRequiredService<SqlServerBenchmarkDbContext>();
+
+      _sqlServerDbContext.CreateComplexCollectionParameter(_objects).Count();
+      TempTable().Wait();
+   }
+
+   [GlobalCleanup]
+   public void Dispose()
+   {
+      _scope?.Dispose();
+      _benchmarkContext?.Dispose();
+   }
+
+   [Benchmark]
+   public int Json()
+   {
+      return _sqlServerDbContext!.CreateComplexCollectionParameter(_objects).Count();
+   }
+
+   [Benchmark]
+   public async Task<int> TempTable()
+   {
+      await using var tempTable = await _sqlServerDbContext!.BulkInsertIntoTempTableAsync(_objects, _sqlServerOptions);
+
+      return tempTable.Query.Count();
+   }
+}

samples/Thinktecture.EntityFrameworkCore.Benchmarks/Benchmarking/ScalarCollectionParameter.cs

@@ -0,0 +1,49 @@
+using BenchmarkDotNet.Attributes;
+using Microsoft.Extensions.DependencyInjection;
+using Thinktecture.Database;
+using Thinktecture.EntityFrameworkCore.BulkOperations;
+
+namespace Thinktecture.Benchmarking;
+
+[MemoryDiagnoser]
+public class ScalarCollectionParameter : IDisposable
+{
+   private BenchmarkContext? _benchmarkContext;
+   private IServiceScope? _scope;
+   private SqlServerBenchmarkDbContext? _sqlServerDbContext;
+   private readonly SqlServerTempTableBulkInsertOptions _sqlServerOptions = new();
+
+   private readonly Guid[] _values = Enumerable.Range(1, 500).Select(i => Guid.NewGuid()).ToArray();
+
+   [GlobalSetup]
+   public void Initialize()
+   {
+      _benchmarkContext = new BenchmarkContext();
+      _scope = _benchmarkContext.RootServiceProvider.CreateScope();
+      _sqlServerDbContext = _scope.ServiceProvider.GetRequiredService<SqlServerBenchmarkDbContext>();
+
+      _sqlServerDbContext.CreateScalarCollectionParameter(_values).Count();
+      TempTable().Wait();
+   }
+
+   [GlobalCleanup]
+   public void Dispose()
+   {
+      _scope?.Dispose();
+      _benchmarkContext?.Dispose();
+   }
+
+   [Benchmark]
+   public int Json()
+   {
+      return _sqlServerDbContext!.CreateScalarCollectionParameter(_values).Count();
+   }
+
+   [Benchmark]
+   public async Task<int> TempTable()
+   {
+      await using var tempTable = await _sqlServerDbContext!.BulkInsertValuesIntoTempTableAsync(_values, _sqlServerOptions);
+
+      return tempTable.Query.Count();
+   }
+}

samples/Thinktecture.EntityFrameworkCore.Benchmarks/Database/BenchmarkDbContext.cs

@@ -11,7 +11,6 @@ protected BenchmarkDbContext(DbContextOptions options)
 
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
-      modelBuilder.ConfigureTempTable<int>();
       modelBuilder.ConfigureTempTable<int, int>();
    }
 }

samples/Thinktecture.EntityFrameworkCore.Benchmarks/Database/MyParameter.cs

@@ -0,0 +1,3 @@
+namespace Thinktecture.Database;
+
+public record MyParameter(Guid Column1, string Column2);

samples/Thinktecture.EntityFrameworkCore.Benchmarks/Database/SqlServerBenchmarkDbContext.cs

@@ -6,4 +6,16 @@ public SqlServerBenchmarkDbContext(DbContextOptions<SqlServerBenchmarkDbContext>
       : base(options)
    {
    }
+
+   /// <inheritdoc />
+   protected override void OnModelCreating(ModelBuilder modelBuilder)
+   {
+      base.OnModelCreating(modelBuilder);
+
+      modelBuilder.ConfigureScalarCollectionParameter<decimal>(builder => builder.Property(e => e.Value).HasPrecision(10, 4));
+
+      modelBuilder.ConfigureComplexCollectionParameter<MyParameter>();
+
+      modelBuilder.ConfigureTempTableEntity<MyParameter>();
+   }
 }

samples/Thinktecture.EntityFrameworkCore.Benchmarks/Program.cs

@@ -2,7 +2,9 @@
 using Thinktecture.Benchmarking;
 
 // BenchmarkRunner.Run<CreateTempTable>();
-BenchmarkRunner.Run<BulkInsertIntoTempTable>();
+// BenchmarkRunner.Run<BulkInsertIntoTempTable>();
+// BenchmarkRunner.Run<ScalarCollectionParameter>();
+BenchmarkRunner.Run<ComplexCollectionParameter>();
 
 // await ExecuteCreateTableAsync();
 // await ExecuteBulkInsertIntoTempTableAsync();

src/Thinktecture.EntityFrameworkCore.BulkOperations/EntityFrameworkCore/BulkOperations/BulkOperationConventionSetPlugin.cs

@@ -0,0 +1,18 @@
+using Microsoft.EntityFrameworkCore.Metadata.Conventions;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
+
+namespace Thinktecture.EntityFrameworkCore.BulkOperations;
+
+/// <summary>
+/// Conventions for bulk operations.
+/// </summary>
+public class BulkOperationConventionSetPlugin : IConventionSetPlugin
+{
+   /// <inheritdoc />
+   public ConventionSet ModifyConventions(ConventionSet conventionSet)
+   {
+      conventionSet.ModelInitializedConventions.Add(TempTableConvention.Instance);
+
+      return conventionSet;
+   }
+}

src/Thinktecture.EntityFrameworkCore.BulkOperations/EntityFrameworkCore/BulkOperations/TempTableConvention.cs

@@ -0,0 +1,49 @@
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions;
+using Thinktecture.EntityFrameworkCore.TempTables;
+using Thinktecture.Internal;
+
+namespace Thinktecture.EntityFrameworkCore.BulkOperations;
+
+/// <summary>
+/// Configures some temp tables for primitive types.
+/// </summary>
+public class TempTableConvention : IModelInitializedConvention
+{
+   /// <summary>
+   /// Singleton.
+   /// </summary>
+   public static readonly IModelInitializedConvention Instance = new TempTableConvention();
+
+   /// <inheritdoc />
+   public void ProcessModelInitialized(IConventionModelBuilder modelBuilder, IConventionContext<IConventionModelBuilder> context)
+   {
+      AddTempTable<int>(modelBuilder);
+      AddTempTable<long>(modelBuilder);
+      AddTempTable<DateTime>(modelBuilder);
+      AddTempTable<Guid>(modelBuilder);
+      AddTempTable<bool>(modelBuilder);
+      AddTempTable<byte>(modelBuilder);
+      AddTempTable<double>(modelBuilder);
+      AddTempTable<DateTimeOffset>(modelBuilder);
+      AddTempTable<short>(modelBuilder);
+      AddTempTable<float>(modelBuilder);
+      AddTempTable<decimal>(modelBuilder);
+      AddTempTable<TimeSpan>(modelBuilder);
+      AddTempTable<string>(modelBuilder);
+   }
+
+   private static void AddTempTable<TColumn1>(IConventionModelBuilder modelBuilder)
+   {
+      var type = typeof(TempTable<TColumn1>);
+      var builder = modelBuilder.SharedTypeEntity(EntityNameProvider.GetTempTableName(type), type, fromDataAnnotation: true);
+
+      if (builder is null)
+         return;
+
+      builder.ToTable($"#{type.ShortDisplayName()}");
+      builder.HasNoKey();
+      builder.ExcludeTableFromMigrations(true);
+   }
+}

src/Thinktecture.EntityFrameworkCore.SqlServer/EntityFrameworkCore/Infrastructure/SqlServerDbContextOptionsExtension.cs

@@ -127,6 +127,8 @@ public void ApplyServices(IServiceCollection services)
 
       if (AddBulkOperationSupport)
       {
+         services.Add<IConventionSetPlugin, BulkOperationConventionSetPlugin>(GetLifetime<IConventionSetPlugin>());
+
          services.AddSingleton<TempTableStatementCache<SqlServerTempTableCreatorCacheKey>>();
          services.AddSingleton<TempTableStatementCache<SqlServerTempTablePrimaryKeyCacheKey>>();
          services.TryAddScoped<ISqlServerTempTableCreator, SqlServerTempTableCreator>();