Pull Request updates

Author: CornerstoneCode

.gitignore

@@ -8,3 +8,7 @@ Sqlite-Concurrency/obj/
 EntityFrameworkCore.Sqlite.Concurrency/obj/
 
 EntityFrameworkCore.Sqlite.Concurrency/bin/
+
+Tests/bin/
+
+Tests/obj/

EntityFrameworkCore.Sqlite.Concurrency/src/Models/SqliteConcurrencyOptions.cs

@@ -3,7 +3,7 @@ namespace EntityFrameworkCore.Sqlite.Concurrency.Models;
 /// <summary>
 /// Options for configuring SQLite concurrency and performance.
 /// </summary>
-public class SqliteConcurrencyOptions
+public class SqliteConcurrencyOptions : IEquatable<SqliteConcurrencyOptions>
 {
     /// <summary>
     /// The maximum number of retry attempts for SQLITE_BUSY errors.
@@ -24,4 +24,30 @@ public class SqliteConcurrencyOptions
     /// The number of pages for WAL auto-checkpoint.
     /// </summary>
     public int WalAutoCheckpoint { get; set; } = 1000;
+
+    /// <inheritdoc />
+    public bool Equals(SqliteConcurrencyOptions? other)
+    {
+        if (other is null) return false;
+        if (ReferenceEquals(this, other)) return true;
+        return MaxRetryAttempts == other.MaxRetryAttempts && 
+               BusyTimeout.Equals(other.BusyTimeout) && 
+               CommandTimeout == other.CommandTimeout && 
+               WalAutoCheckpoint == other.WalAutoCheckpoint;
+    }
+
+    /// <inheritdoc />
+    public override bool Equals(object? obj)
+    {
+        if (obj is null) return false;
+        if (ReferenceEquals(this, obj)) return true;
+        if (obj.GetType() != GetType()) return false;
+        return Equals((SqliteConcurrencyOptions)obj);
+    }
+
+    /// <inheritdoc />
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(MaxRetryAttempts, BusyTimeout, CommandTimeout, WalAutoCheckpoint);
+    }
 }

EntityFrameworkCore.Sqlite.Concurrency/src/SqliteConcurrencyExtensions.cs

@@ -92,6 +92,7 @@ public static async Task BulkInsertOptimizedAsync<T>(
         {
             await context.AddRangeAsync(entities, cancellationToken);
             await context.SaveChangesAsync(cancellationToken);
+            context.ChangeTracker.Clear();
             return;
         }
 
@@ -114,6 +115,7 @@ public static async Task BulkInsertOptimizedAsync<T>(
             {
                 await context.AddRangeAsync(batch, cancellationToken);
                 await context.SaveChangesAsync(cancellationToken);
+                context.ChangeTracker.Clear();
             }
 
             await transaction.CommitAsync(cancellationToken);

EntityFrameworkCore.Sqlite.Concurrency/src/SqliteConcurrencyInterceptor.cs

@@ -14,6 +14,11 @@ public class SqliteConcurrencyInterceptor : DbCommandInterceptor, IDbConnectionI
     private readonly SemaphoreSlim _writeLock;
     private readonly string _connectionString;
 
+    /// <summary>
+    /// Gets the concurrency options configured for this interceptor.
+    /// </summary>
+    public SqliteConcurrencyOptions Options => _options;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="SqliteConcurrencyInterceptor"/> class.
     /// </summary>

EntityFrameworkCore.Sqlite.Concurrency/src/SqliteConnectionEnhancer.cs

@@ -57,11 +57,37 @@ public static SemaphoreSlim GetWriteLock(string connectionString)
     /// <param name="connectionString">The connection string.</param>
     /// <param name="options">The concurrency options.</param>
     /// <returns>A <see cref="SqliteConcurrencyInterceptor"/> instance.</returns>
+    /// <exception cref="ArgumentException">Thrown when the provided <paramref name="options"/> do not match the options of an existing interceptor for the same <paramref name="connectionString"/>.</exception>
+    /// <remarks>
+    /// Callers must use consistent options for the same connection string, as interceptors are cached and shared.
+    /// </remarks>
     public static SqliteConcurrencyInterceptor GetInterceptor(string connectionString, SqliteConcurrencyOptions options)
     {
+        if (_interceptors.TryGetValue(connectionString, out var existingInterceptor))
+        {
+            if (!existingInterceptor.Options.Equals(options))
+            {
+                throw new ArgumentException(
+                    $"Mismatched SqliteConcurrencyOptions for connection string. " +
+                    $"Existing options: {FormatOptions(existingInterceptor.Options)}, " +
+                    $"Incoming options: {FormatOptions(options)}. " +
+                    $"Interceptors are shared per connection string and must be configured consistently.",
+                    nameof(options));
+            }
+            return existingInterceptor;
+        }
+
         return _interceptors.GetOrAdd(connectionString, cs => new SqliteConcurrencyInterceptor(options, cs));
     }
 
+    private static string FormatOptions(SqliteConcurrencyOptions options)
+    {
+        return $"[MaxRetryAttempts={options.MaxRetryAttempts}, " +
+               $"BusyTimeout={options.BusyTimeout}, " +
+               $"CommandTimeout={options.CommandTimeout}, " +
+               $"WalAutoCheckpoint={options.WalAutoCheckpoint}]";
+    }
+
     private static string ComputeOptimizedConnectionString(string originalConnectionString)
     {
         var builder = new SqliteConnectionStringBuilder(originalConnectionString)
@@ -98,20 +124,34 @@ public static void ApplyRuntimePragmas(DbConnection connection, SqliteConcurrenc
         var dataSource = builder.DataSource;
 
         // 1. Database-scoped Pragmas - Run once per process
-        if (_initializedDatabases.TryAdd(dataSource, true))
+        if (!_initializedDatabases.ContainsKey(dataSource))
         {
             var lockObj = _pragmaLocks.GetOrAdd(dataSource, _ => new object());
             lock (lockObj)
             {
-                using var initCommand = sqliteConnection.CreateCommand();
-                initCommand.CommandText = $@"
-                    PRAGMA journal_mode = WAL;
-                    PRAGMA page_size = 4096;
-                    PRAGMA auto_vacuum = INCREMENTAL;
-                    PRAGMA journal_size_limit = 134217728;
-                    PRAGMA wal_autocheckpoint = {options.WalAutoCheckpoint};
-                ";
-                initCommand.ExecuteNonQuery();
+                if (!_initializedDatabases.ContainsKey(dataSource))
+                {
+                    try
+                    {
+                        using var initCommand = sqliteConnection.CreateCommand();
+                        initCommand.CommandText = $@"
+                            PRAGMA journal_mode = WAL;
+                            PRAGMA page_size = 4096;
+                            PRAGMA auto_vacuum = INCREMENTAL;
+                            PRAGMA journal_size_limit = 134217728;
+                            PRAGMA wal_autocheckpoint = {options.WalAutoCheckpoint};
+                        ";
+                        initCommand.ExecuteNonQuery();
+                        
+                        _initializedDatabases.TryAdd(dataSource, true);
+                    }
+                    catch
+                    {
+                        // Ensure we don't leave it marked as initialized if it failed
+                        _initializedDatabases.TryRemove(dataSource, out _);
+                        throw;
+                    }
+                }
             }
         }