Drop table.

Author: SebastianStehle

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

@@ -20,10 +20,12 @@ internal class SqliteBulkInsertProvider(ILogger<SqliteBulkInsertProvider>? logge
     /// <inheritdoc />
     protected override string BulkInsertId => "rowid";
 
-    //language=sql
     /// <inheritdoc />
     protected override string AddTableCopyBulkInsertId => "--"; // No need to add an ID column in SQLite
 
+    /// <inheritdoc />
+    protected override string GetTempTableName(string tableName) => $"_temp_bulk_insert_test_entity_{Guid.NewGuid():N}";
+
     /// <inheritdoc />
     protected override BulkInsertOptions CreateDefaultOptions() => new()
     {
@@ -116,6 +118,12 @@ private static DbCommand GetInsertCommand(
         return command;
     }
 
+    /// <inheritdoc />
+    protected override Task DropTempTableAsync(bool sync, DbContext dbContext, string tableName)
+    {
+        return ExecuteAsync(sync, dbContext, $"DROP TABLE IF EXISTS {tableName}", default);
+    }
+
     /// <inheritdoc />
     protected override async Task BulkInsert<T>(
         bool sync,

src/PhenX.EntityFrameworkCore.BulkInsert/BulkInsertProviderBase.cs

@@ -1,4 +1,5 @@
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Storage;
@@ -43,14 +44,20 @@ protected override async IAsyncEnumerable<T> BulkInsertReturnEntities<T>(
             }
 
             var tableName = await PerformBulkInsertAsync(sync, context, tableInfo, entities, options, tempTableRequired: true, ctk: ctk);
+            try
+            {
+                var result =
+                    await CopyFromTempTableAsync<T, T>(sync, context, tableInfo, tableName, true, options, onConflict, ctk: ctk)
+                        ?? throw new InvalidOperationException("Copy returns null enumerable.");
 
-            var result =
-                await CopyFromTempTableAsync<T, T>(sync, context, tableInfo, tableName, true, options, onConflict, ctk: ctk)
-                    ?? throw new InvalidOperationException("Copy returns null enumerable.");
-
-            await foreach (var item in result.WithCancellation(ctk))
+                await foreach (var item in result.WithCancellation(ctk))
+                {
+                    yield return item;
+                }
+            }
+            finally
             {
-                yield return item;
+                await PerformDropTempTableAsync(sync, context, tableName);
             }
 
             // Commit the transaction if we own them.
@@ -71,6 +78,11 @@ protected override async Task BulkInsert<T>(
         OnConflictOptions<T>? onConflict,
         CancellationToken ctk) where T : class
     {
+        if (entities.TryGetNonEnumeratedCount(out var count) && count == 0)
+        {
+            throw new InvalidOperationException("No entities to insert.");
+        }
+
         using var activity = Telemetry.ActivitySource.StartActivity("BulkInsert");
         activity?.AddTag("tableName", tableInfo.TableName);
         activity?.AddTag("synchronous", sync);
@@ -86,8 +98,14 @@ protected override async Task BulkInsert<T>(
                 }
 
                 var tableName = await PerformBulkInsertAsync(sync, context, tableInfo, entities, options, tempTableRequired: true, ctk: ctk);
-
-                await CopyFromTempTableAsync<T, T>(sync, context, tableInfo, tableName, false, options, onConflict, ctk);
+                try
+                {
+                    await CopyFromTempTableAsync<T, T>(sync, context, tableInfo, tableName, false, options, onConflict, ctk);
+                }
+                finally
+                {
+                    await PerformDropTempTableAsync(sync, context, tableName);
+                }
             }
             else
             {
@@ -107,7 +125,6 @@ protected override async Task BulkInsert<T>(
             await connection.Close(sync, ctk);
         }
     }
-
     private async Task<string> PerformBulkInsertAsync<T>(
         bool sync,
         DbContext context,
@@ -117,11 +134,6 @@ private async Task<string> PerformBulkInsertAsync<T>(
         bool tempTableRequired,
         CancellationToken ctk) where T : class
     {
-        if (entities.TryGetNonEnumeratedCount(out var count) && count == 0)
-        {
-            throw new InvalidOperationException("No entities to insert.");
-        }
-
         var tableName = tempTableRequired
             ? await CreateTableCopyAsync<T>(sync, context, options, tableInfo, ctk)
             : tableInfo.QuotedTableName;
@@ -208,6 +220,33 @@ protected virtual async Task AddBulkInsertIdColumn<T>(
         return null;
     }
 
+    private async Task PerformDropTempTableAsync(bool sync, DbContext dbContext, string tableName)
+    {
+        try
+        {
+            await DropTempTableAsync(sync, dbContext, tableName);
+        }
+        catch (Exception ex)
+        {
+            // The drop operation is not mandatory, therefore never fail the actual operation.
+            if (logger != null)
+            {
+                Log.DropTemporaryTableFailed(logger, ex);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Drops the temporary table manually if needed.
+    /// </summary>
+    /// <param name="sync">Indicates if the operation is synchronous.</param>
+    /// <param name="dbContext">The context.</param>
+    /// <param name="tableName">The table name.</param>
+    protected virtual Task DropTempTableAsync(bool sync, DbContext dbContext, string tableName)
+    {
+        return Task.CompletedTask;
+    }
+
     protected static async Task ExecuteAsync(
         bool sync,
         DbContext context,

src/PhenX.EntityFrameworkCore.BulkInsert/BulkInsertProviderUntyped.cs

@@ -36,6 +36,11 @@ public IAsyncEnumerable<T> BulkInsertReturnEntities<T>(
             throw new InvalidOperationException($"Invalid options type: {options.GetType().Name}. Expected: {typeof(TOptions).Name}");
         }
 
+        if (entities.TryGetNonEnumeratedCount(out var count) && count == 0)
+        {
+            throw new InvalidOperationException("No entities to insert.");
+        }
+
         return BulkInsertReturnEntities(sync, context, tableInfo, entities, providerOptions, onConflict, ctk);
     }
 
@@ -62,6 +67,11 @@ public Task BulkInsert<T>(
             throw new InvalidOperationException($"Invalid options type: {options.GetType().Name}. Expected: {typeof(TOptions).Name}");
         }
 
+        if (entities.TryGetNonEnumeratedCount(out var count) && count == 0)
+        {
+            throw new InvalidOperationException("No entities to insert.");
+        }
+
         return BulkInsert(sync, context, tableInfo, entities, providerOptions, onConflict, ctk);
     }
 

src/PhenX.EntityFrameworkCore.BulkInsert/Log.cs

@@ -21,4 +21,10 @@ internal static partial class Log
         Level = LogLevel.Trace,
         Message = "Insert to table directly")]
     public static partial void UsingDirectInsert(ILogger logger);
+
+    [LoggerMessage(
+        EventId = 1003,
+        Level = LogLevel.Error,
+        Message = "Failed to drop temporary table.")]
+    public static partial void DropTemporaryTableFailed(ILogger logger, Exception exception);
 }