Add support for provider specific options

Author: fabien.menager

src/PhenX.EntityFrameworkCore.BulkInsert.MySql/MySqlBulkInsertProvider.cs

@@ -25,6 +25,9 @@ public MySqlBulkInsertProvider(ILogger<MySqlBulkInsertProvider>? logger = null)
     /// <inheritdoc />
     protected override string GetTempTableName(string tableName) => $"#_temp_bulk_insert_{tableName}";
 
+    /// <inheritdoc />
+    public override BulkInsertOptions GetDefaultOptions() => new();
+
     /// <inheritdoc />
     public override Task<List<T>> BulkInsertReturnEntities<T>(
         bool sync,

src/PhenX.EntityFrameworkCore.BulkInsert.PostgreSql/PostgreSqlBulkInsertProvider.cs

@@ -31,6 +31,12 @@ private string GetBinaryImportCommand(DbContext context, Type entityType, string
         return $"COPY {tableName} ({string.Join(", ", columns)}) FROM STDIN (FORMAT BINARY)";
     }
 
+    /// <inheritdoc />
+    public override BulkInsertOptions GetDefaultOptions() => new()
+    {
+        BatchSize = 50_000,
+    };
+
     /// <inheritdoc />
     protected override async Task BulkInsert<T>(
         bool sync,

src/PhenX.EntityFrameworkCore.BulkInsert.SqlServer/SqlServerBulkInsertOptions.cs

@@ -0,0 +1,15 @@
+using Microsoft.Data.SqlClient;
+
+using PhenX.EntityFrameworkCore.BulkInsert.Options;
+
+namespace PhenX.EntityFrameworkCore.BulkInsert.SqlServer;
+
+/// <summary>
+/// Options specific to SQL Server bulk insert.
+/// </summary>
+public class SqlServerBulkInsertOptions : BulkInsertOptions
+{
+    /// <inheritdoc cref="SqlBulkCopyOptions"/>
+    public SqlBulkCopyOptions CopyOptions { get; init; } = SqlBulkCopyOptions.Default;
+
+}

src/PhenX.EntityFrameworkCore.BulkInsert.SqlServer/SqlServerBulkInsertProvider.cs

@@ -27,6 +27,11 @@ public SqlServerBulkInsertProvider(ILogger<SqlServerBulkInsertProvider>? logger
     /// <inheritdoc />
     protected override string GetTempTableName(string tableName) => $"#_temp_bulk_insert_{tableName}";
 
+    public override BulkInsertOptions GetDefaultOptions() => new SqlServerBulkInsertOptions
+    {
+        BatchSize = 50_000,
+    };
+
     /// <inheritdoc />
     protected override async Task BulkInsert<T>(
         bool sync,
@@ -43,7 +48,7 @@ CancellationToken ctk
 
         using var bulkCopy = new SqlBulkCopy(connection, SqlBulkCopyOptions.TableLock, sqlTransaction);
         bulkCopy.DestinationTableName = tableName;
-        bulkCopy.BatchSize = options.BatchSize ?? 50_000;
+        bulkCopy.BatchSize = options.BatchSize;
         bulkCopy.BulkCopyTimeout = options.GetCopyTimeoutInSeconds();
 
         foreach (var prop in properties)

src/PhenX.EntityFrameworkCore.BulkInsert.Sqlite/SqliteBulkInsertProvider.cs

@@ -29,6 +29,12 @@ public SqliteBulkInsertProvider(ILogger<SqliteBulkInsertProvider>? logger = null
     /// <inheritdoc />
     protected override string AddTableCopyBulkInsertId => "--"; // No need to add an ID column in SQLite
 
+    /// <inheritdoc />
+    public override BulkInsertOptions GetDefaultOptions() => new()
+    {
+        BatchSize = 5,
+    };
+
     /// <inheritdoc />
     protected override Task AddBulkInsertIdColumn<T>(
         bool sync,
@@ -134,7 +140,7 @@ CancellationToken ctk
     ) where T : class
     {
         const int maxParams = 1000;
-        var batchSize = options.BatchSize ?? 5;
+        var batchSize = options.BatchSize;
         batchSize = Math.Min(batchSize, maxParams / properties.Length);
 
         await using var insertCommand = GetInsertCommand(context, typeof(T), tableName, options, batchSize);

src/PhenX.EntityFrameworkCore.BulkInsert/Abstractions/IBulkInsertProvider.cs

@@ -32,4 +32,9 @@ internal Task BulkInsert<T>(
         OnConflictOptions? onConflict = null,
         CancellationToken ctk = default
     ) where T : class;
+
+    /// <summary>
+    /// Make the default options for the provider, can be a subclass of <see cref="BulkInsertOptions"/>.
+    /// </summary>
+    internal BulkInsertOptions GetDefaultOptions();
 }

src/PhenX.EntityFrameworkCore.BulkInsert/BulkInsertProviderBase.cs

@@ -216,6 +216,8 @@ public virtual async Task BulkInsert<T>(
         }
     }
 
+    public abstract BulkInsertOptions GetDefaultOptions();
+
     private async Task<(string TableName, DbConnection Connection)> PerformBulkInsertAsync<T>(
         bool sync,
         DbContext context,

src/PhenX.EntityFrameworkCore.BulkInsert/Extensions/DbSetExtensions.cs

@@ -12,25 +12,60 @@ namespace PhenX.EntityFrameworkCore.BulkInsert.Extensions;
 public static class DbSetExtensions
 {
     /// <summary>
-    /// Executes a bulk insert operation returning the inserted/updated entities, from the DbSet.
+    /// Executes a bulk insert operation returning the inserted/updated entities, from the DbSet, with options which
+    /// can be a subclass of <see cref="BulkInsertOptions"/>.
     /// </summary>
-    public static async Task<List<T>> ExecuteBulkInsertReturnEntitiesAsync<T>(
+    public static async Task<List<T>> ExecuteBulkInsertReturnEntitiesAsync<T, TOptions>(
         this DbSet<T> dbSet,
         IEnumerable<T> entities,
-        Action<BulkInsertOptions>? configure = null,
+        Action<TOptions> configure,
         OnConflictOptions? onConflict = null,
         CancellationToken ctk = default
-    ) where T : class
+    )
+        where T : class
+        where TOptions : BulkInsertOptions
     {
         var provider = InitProvider(dbSet, configure, out var context, out var options);
 
         return await provider.BulkInsertReturnEntities(false, context, entities, options, onConflict, ctk);
     }
 
+    /// <summary>
+    /// Executes a bulk insert operation returning the inserted/updated entities, from the DbSet without options.
+    /// </summary>
+    public static async Task<List<T>> ExecuteBulkInsertReturnEntitiesAsync<T>(
+        this DbSet<T> dbSet,
+        IEnumerable<T> entities,
+        Action<BulkInsertOptions> configure,
+        OnConflictOptions? onConflict = null,
+        CancellationToken ctk = default
+    ) where T : class
+        => await ExecuteBulkInsertReturnEntitiesAsync<T, BulkInsertOptions>(dbSet, entities, configure, onConflict, ctk);
+
+
+    /// <summary>
+    /// Executes a bulk insert operation returning the inserted/updated entities, from the DbSet without options.
+    /// </summary>
+    public static async Task<List<T>> ExecuteBulkInsertReturnEntitiesAsync<T>(
+        this DbSet<T> dbSet,
+        IEnumerable<T> entities,
+        OnConflictOptions? onConflict = null,
+        CancellationToken ctk = default
+    ) where T : class
+        => await ExecuteBulkInsertReturnEntitiesAsync<T, BulkInsertOptions>(dbSet, entities, _ => { }, onConflict, ctk);
+
     /// <summary>
     /// Executes a bulk insert operation returning the inserted/updated entities, from the DbContext.
     /// </summary>
-    public static async Task<List<T>> ExecuteBulkInsertReturnEntitiesAsync<T>(this DbContext dbContext, IEnumerable<T> entities, Action<BulkInsertOptions>? configure = null, OnConflictOptions? onConflict = null, CancellationToken cancellationToken = default) where T : class
+    public static async Task<List<T>> ExecuteBulkInsertReturnEntitiesAsync<T, TOptions>(
+        this DbContext dbContext,
+        IEnumerable<T> entities,
+        Action<TOptions> configure,
+        OnConflictOptions? onConflict = null,
+        CancellationToken cancellationToken = default
+    )
+        where T : class
+        where TOptions : BulkInsertOptions
     {
         var dbSet = dbContext.Set<T>();
         if (dbSet == null)
@@ -41,16 +76,41 @@ public static async Task<List<T>> ExecuteBulkInsertReturnEntitiesAsync<T>(this D
         return await dbSet.ExecuteBulkInsertReturnEntitiesAsync(entities, configure, onConflict, cancellationToken);
     }
 
+    /// <summary>
+    /// Executes a bulk insert operation returning the inserted/updated entities, from the DbContext, with generic options.
+    /// </summary>
+    public static async Task<List<T>> ExecuteBulkInsertReturnEntitiesAsync<T>(
+        this DbContext dbContext,
+        IEnumerable<T> entities,
+        Action<BulkInsertOptions> configure,
+        OnConflictOptions? onConflict = null,
+        CancellationToken cancellationToken = default
+    ) where T : class
+        => await ExecuteBulkInsertReturnEntitiesAsync<T, BulkInsertOptions>(dbContext, entities, configure, onConflict, cancellationToken);
+
+    /// <summary>
+    /// Executes a bulk insert operation returning the inserted/updated entities, from the DbContext, with generic options.
+    /// </summary>
+    public static async Task<List<T>> ExecuteBulkInsertReturnEntitiesAsync<T>(
+        this DbContext dbContext,
+        IEnumerable<T> entities,
+        OnConflictOptions? onConflict = null,
+        CancellationToken cancellationToken = default
+    ) where T : class =>
+        await dbContext.ExecuteBulkInsertReturnEntitiesAsync<T, BulkInsertOptions>(entities, _ => { }, onConflict, cancellationToken);
+
     /// <summary>
     /// Executes a bulk insert operation without returning the inserted/updated entities, from the DbSet.
     /// </summary>
-    public static async Task ExecuteBulkInsertAsync<T>(
+    public static async Task ExecuteBulkInsertAsync<T, TOptions>(
         this DbSet<T> dbSet,
         IEnumerable<T> entities,
-        Action<BulkInsertOptions>? configure = null,
+        Action<TOptions> configure,
         OnConflictOptions? onConflict = null,
         CancellationToken ctk = default
-    ) where T : class
+    )
+        where T : class
+        where TOptions : BulkInsertOptions
     {
         var provider = InitProvider(dbSet, configure, out var context, out var options);
 
@@ -60,7 +120,14 @@ public static async Task ExecuteBulkInsertAsync<T>(
     /// <summary>
     /// Executes a bulk insert operation without returning the inserted/updated entities, from the DbContext.
     /// </summary>
-    public static async Task ExecuteBulkInsertAsync<T>(this DbContext dbContext, IEnumerable<T> entities, Action<BulkInsertOptions>? configure = null, OnConflictOptions? onConflict = null, CancellationToken cancellationToken = default) where T : class
+    public static async Task ExecuteBulkInsertAsync<T>(
+        this DbContext dbContext,
+        IEnumerable<T> entities,
+        Action<BulkInsertOptions> configure,
+        OnConflictOptions? onConflict = null,
+        CancellationToken cancellationToken = default
+    )
+        where T : class
     {
         var dbSet = dbContext.Set<T>();
         if (dbSet == null)
@@ -71,6 +138,25 @@ public static async Task ExecuteBulkInsertAsync<T>(this DbContext dbContext, IEn
         await dbSet.ExecuteBulkInsertAsync(entities, configure, onConflict, cancellationToken);
     }
 
+    /// <summary>
+    /// Executes a bulk insert operation without returning the inserted/updated entities, from the DbContext.
+    /// </summary>
+    public static async Task ExecuteBulkInsertAsync<T>(
+        this DbContext dbContext,
+        IEnumerable<T> entities,
+        OnConflictOptions? onConflict = null,
+        CancellationToken cancellationToken = default
+    ) where T : class
+    {
+        var dbSet = dbContext.Set<T>();
+        if (dbSet == null)
+        {
+            throw new InvalidOperationException($"DbSet of type {typeof(T).Name} not found in DbContext.");
+        }
+
+        await dbSet.ExecuteBulkInsertAsync<T, BulkInsertOptions>(entities, _ => { }, onConflict, cancellationToken);
+    }
+
     /// <summary>
     /// Executes a bulk insert operation returning the inserted/updated entities, from the DbSet (synchronous variant).
     /// </summary>
@@ -145,14 +231,22 @@ private static DbContext GetDbContext<T>(this DbSet<T> dbSet) where T : class
         return (infrastructure.Instance.GetService(typeof(ICurrentDbContext)) as ICurrentDbContext)!.Context;
     }
 
-    private static IBulkInsertProvider InitProvider<T>(DbSet<T> dbSet, Action<BulkInsertOptions>? configure, out DbContext context,
-        out BulkInsertOptions options) where T : class
+    private static IBulkInsertProvider InitProvider<T, TOptions>(DbSet<T> dbSet, Action<TOptions>? configure, out DbContext context,
+        out TOptions options) where T : class where TOptions : BulkInsertOptions
     {
         context = dbSet.GetDbContext();
         var provider = context.GetService<IBulkInsertProvider>();
 
-        options = new BulkInsertOptions();
+        var defaultOptions = provider.GetDefaultOptions();
+
+        if (defaultOptions is not TOptions castedOptions)
+        {
+            throw new InvalidOperationException($"Options type mismatch. Expected {defaultOptions.GetType().Name}, but got {typeof(TOptions).Name}.");
+        }
+
+        options = castedOptions;
         configure?.Invoke(options);
+
         return provider;
     }
 }

src/PhenX.EntityFrameworkCore.BulkInsert/Options/BulkInsertOptions.cs

@@ -31,17 +31,17 @@ public class BulkInsertOptions
     /// </item>
     /// </list>
     /// </summary>
-    public int? BatchSize { get; set; }
+    public int BatchSize { get; set; }
 
     /// <summary>
     /// Indicates if also generated columns should be copied. This is useful for upsert operations.
     /// </summary>
     public bool CopyGeneratedColumns { get; set; }
-    
+
     /// <summary>
     /// The timeout to copy records.
     /// </summary>
-    public TimeSpan CopyTimeout = TimeSpan.FromMinutes(10);
+    public TimeSpan CopyTimeout { get; set; } = TimeSpan.FromMinutes(10);
 
     internal int GetCopyTimeoutInSeconds()
     {