v0.1.3

ivanvoyager · ivanvoyager · commit 4cb66a3d4a76 · 2024-10-22T02:05:40.000+03:00
diff --git a/src/NuExt.System.Data.SQLite.csproj b/src/NuExt.System.Data.SQLite.csproj
@@ -14,7 +14,7 @@ System.Data.SQLite.SQLiteDbConnection
 System.Data.SQLite.SQLiteDbContext
 System.Data.SQLite.SQLiteDbConverter
 System.Data.SQLite.SQLiteDbTransaction</Description>
-    <Version>0.1.2</Version>
+    <Version>0.1.3</Version>
     <RootNamespace />
     <GenerateDocumentationFile>True</GenerateDocumentationFile>
     <NoWarn>$(NoWarn);1591</NoWarn>
@@ -24,11 +24,11 @@ System.Data.SQLite.SQLiteDbTransaction</Description>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="System.Data.SQLite.Core" Version="1.0.118" />
+    <PackageReference Include="System.Data.SQLite.Core" Version="1.0.119" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(UseNuExtPackages)' == 'true'">
-    <PackageReference Include="NuExt.System.Data" Version="0.1.2" />
+    <PackageReference Include="NuExt.System.Data" Version="0.1.3" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(UseNuExtPackages)' == 'false'">
diff --git a/src/System/Data/SQLite/SQLiteDbConnection.Transactions.cs b/src/System/Data/SQLite/SQLiteDbConnection.Transactions.cs
@@ -10,33 +10,31 @@ partial class SQLiteDbConnection
         public SQLiteDbTransaction BeginTransaction()
         {
             CheckDisposed();
-            Debug.Assert(_inTransaction == 0);
-            Interlocked.Increment(ref _inTransaction);
+            Debug.Assert(TransactionCount == 0, "Transaction count should be zero before starting a new transaction.");
+            Throw.InvalidOperationExceptionIf(InTransaction, "SQLite does not support nested transactions");
             try
             {
-                return new SQLiteDbTransaction(this, _conn.BeginTransaction(), () => Interlocked.Decrement(ref _inTransaction));
+                return new SQLiteDbTransaction(this, _conn.BeginTransaction());
             }
             catch (Exception ex)
             {
                 Debug.Assert(_assertsDisabled, ex.GetType() + ": " + ex.Message);
-                Interlocked.Decrement(ref _inTransaction);
                 throw;
             }
         }
 
         public SQLiteDbTransaction BeginTransaction(IsolationLevel isolationLevel)
         {
             CheckDisposed();
-            Debug.Assert(_inTransaction == 0);
-            Interlocked.Increment(ref _inTransaction);
+            Debug.Assert(TransactionCount == 0, "Transaction count should be zero before starting a new transaction.");
+            Throw.InvalidOperationExceptionIf(InTransaction, "SQLite does not support nested transactions");
             try
             {
-                return new SQLiteDbTransaction(this, _conn.BeginTransaction(isolationLevel), () => Interlocked.Decrement(ref _inTransaction));
+                return new SQLiteDbTransaction(this, _conn.BeginTransaction(isolationLevel));
             }
             catch (Exception ex)
             {
                 Debug.Assert(_assertsDisabled, ex.GetType() + ": " + ex.Message);
-                Interlocked.Decrement(ref _inTransaction);
                 throw;
             }
         }
diff --git a/src/System/Data/SQLite/SQLiteDbConnection.cs b/src/System/Data/SQLite/SQLiteDbConnection.cs
@@ -14,7 +14,7 @@ public sealed partial class SQLiteDbConnection : Disposable, IDbConnection
     {
         private readonly SQLiteConnection _conn;
         private SQLiteDbConnectionFactory.AsyncLockCounter _syncRoot;
-        private volatile int _inTransaction;
+        internal volatile int TransactionCount;
 
         /// <summary>
         /// Initializes the connection with the specified connection string.
@@ -37,12 +37,12 @@ public SQLiteDbConnection(string connectionString, bool useSharedLock)
 #else
             Throw.IfNullOrEmpty(connectionString);
 #endif
-            _ = new SQLiteConnectionStringBuilder(connectionString);//throws if connection string is invalid
+            var csb = new SQLiteConnectionStringBuilder(connectionString);//throws if connection string is invalid
             _conn = new SQLiteConnection(connectionString);
             UseSharedLock = useSharedLock;
             if (useSharedLock)
             {
-                _syncRoot = SQLiteDbConnectionFactory.Instance.GetSyncObj(connectionString);
+                _syncRoot = SQLiteDbConnectionFactory.Instance.GetSyncObj(csb.DataSource);
             }
             else
             {
@@ -66,7 +66,7 @@ public int DefaultTimeout
             set => _conn.DefaultTimeout = value;
         }
 
-        public bool InTransaction => _inTransaction > 0;
+        public bool InTransaction => TransactionCount > 0;
 
         /// <summary>
         /// Determines whether the current connection holds the database lock.
@@ -125,15 +125,14 @@ public void Close(ConnectionState originalState)
         protected override void OnDispose()
         {
             Close();
-            var connectionString = _conn.ConnectionString;
             _conn.Dispose();
 
             var syncRoot = Interlocked.Exchange(ref _syncRoot!, null);
             if (syncRoot != null)
             {
                 if (UseSharedLock)
                 {
-                    if (SQLiteDbConnectionFactory.Instance.TryRelease(connectionString))
+                    if (SQLiteDbConnectionFactory.Instance.TryRelease(syncRoot.DataSource!))
                     {
                         Debug.Assert(syncRoot.IsDisposed);
                     }
diff --git a/src/System/Data/SQLite/SQLiteDbConnectionFactory.cs b/src/System/Data/SQLite/SQLiteDbConnectionFactory.cs
@@ -6,10 +6,11 @@ internal class SQLiteDbConnectionFactory
 
         internal class AsyncLockCounter : Disposable
         {
-            public readonly ReentrantAsyncLock Mutex = new();
-            public volatile int ReferenceCount;
+            internal readonly ReentrantAsyncLock Mutex = new();
+            internal volatile int ReferenceCount;
+            internal string? DataSource;
 #if DEBUG
-            public bool IsExpired => ReferenceCount <= 0;
+            internal bool IsExpired => ReferenceCount <= 0;
 #endif
             protected override void OnDispose()
             {
@@ -43,28 +44,28 @@ private SQLiteDbConnectionFactory()
         /// <summary>
         /// Gets an object that can be used to synchronize access to the database.
         /// </summary>
-        internal AsyncLockCounter GetSyncObj(string connectionString)
+        internal AsyncLockCounter GetSyncObj(string dataSource)
         {
             AsyncLockCounter? syncObject;
             lock (_sharedLocks)
             {
-                if (!_sharedLocks.TryGetValue(connectionString, out syncObject))
+                if (!_sharedLocks.TryGetValue(dataSource, out syncObject))
                 {
-                    _sharedLocks.Add(connectionString, syncObject = new AsyncLockCounter());
+                    _sharedLocks.Add(dataSource, syncObject = new AsyncLockCounter() { DataSource = dataSource });
                 }
                 Interlocked.Increment(ref syncObject.ReferenceCount);
             }
             return syncObject;
         }
 
-        internal bool TryRelease(string connectionString)
+        internal bool TryRelease(string dataSource)
         {
             lock (_sharedLocks)
             {
-                if (_sharedLocks.TryGetValue(connectionString, out var syncObject) && 
+                if (_sharedLocks.TryGetValue(dataSource, out var syncObject) && 
                     Interlocked.Decrement(ref syncObject.ReferenceCount) <= 0)
                 {
-                    _sharedLocks.Remove(connectionString);
+                    _sharedLocks.Remove(dataSource);
                     syncObject.Dispose();
                     return true;
                 }
diff --git a/src/System/Data/SQLite/SQLiteDbTransaction.cs b/src/System/Data/SQLite/SQLiteDbTransaction.cs
@@ -14,9 +14,8 @@ public sealed class SQLiteDbTransaction : Disposable, IDbTransaction
         private const int ROLLBACK = 2;
         #endregion
 
-        private SQLiteDbConnection? _connection;
-        private SQLiteTransaction? _transaction;
-        private Action? _onDispose;
+        private readonly SQLiteDbConnection _connection;
+        private readonly SQLiteTransaction _transaction;
 
         private int _state = NONE;
 
@@ -29,13 +28,12 @@ public sealed class SQLiteDbTransaction : Disposable, IDbTransaction
         /// </summary>
         /// <param name="connection">The SQLite database connection.</param>
         /// <param name="transaction">The underlying SQLite transaction.</param>
-        /// <param name="onDispose">An action to perform upon disposal.</param>
         /// <exception cref="ArgumentNullException">Thrown when the provided connection or transaction is null.</exception>
-        internal SQLiteDbTransaction(SQLiteDbConnection connection, SQLiteTransaction transaction, Action? onDispose)
+        internal SQLiteDbTransaction(SQLiteDbConnection connection, SQLiteTransaction transaction)
         {
             _connection = connection ?? throw new ArgumentNullException(nameof(connection));
             _transaction = transaction ?? throw new ArgumentNullException(nameof(transaction));
-            _onDispose = onDispose;
+            Interlocked.Increment(ref _connection.TransactionCount);
             Debug.Assert(connection.DefaultTimeout == 30);
         }
 
@@ -44,12 +42,12 @@ internal SQLiteDbTransaction(SQLiteDbConnection connection, SQLiteTransaction tr
         /// <summary>
         /// Gets the database connection associated with this transaction.
         /// </summary>
-        public IDbConnection Connection => _transaction!.Connection;
+        public IDbConnection Connection => _transaction.Connection;
 
         /// <summary>
         /// Gets the isolation level of this transaction.
         /// </summary>
-        public IsolationLevel IsolationLevel => _transaction!.IsolationLevel;
+        public IsolationLevel IsolationLevel => _transaction.IsolationLevel;
 
         #endregion
 
@@ -79,32 +77,30 @@ public void Commit()
         {
             CheckDisposed();
             var originalState = Interlocked.CompareExchange(ref _state, COMMIT, NONE);
-            if (originalState != NONE)
-            {
-                Debug.Assert(false, $"Trying commit with state: {originalState}");
-                return;
-            }
-            _transaction!.Commit();
+            Debug.Assert(originalState == NONE, $"Trying commit with state: {originalState}");
+            Throw.InvalidOperationExceptionIf(originalState != NONE, $"Trying commit with state: {originalState}");
+            _transaction.Commit();
         }
 
         /// <summary>
         /// Disposes the resources used by this transaction.
         /// </summary>
         protected override void OnDispose()
         {
-            DisposeAndNull(ref _transaction);
-            if (_onDispose != null)
+            try
             {
-                _onDispose();
-                _onDispose = null;
+                _transaction.Dispose();
             }
+            finally
+            {
+                Interlocked.Decrement(ref _connection.TransactionCount);
 #if DEBUG
-            var elapsed = _watch.Elapsed;
-            var timeout = _connection?.DefaultTimeout;
-            Debug.Assert(elapsed.TotalSeconds < timeout, $"Transaction elapsed: {elapsed}, Expected: {timeout} sec");
+                var elapsed = _watch.Elapsed;
+                var timeout = _connection.DefaultTimeout;
+                Debug.Assert(elapsed.TotalSeconds < timeout, $"Transaction elapsed: {elapsed}, Expected: {timeout} sec");
 #endif
-            _connection = null;
-            base.OnDispose();
+                base.OnDispose();
+            }
         }
 
         /// <summary>
@@ -114,15 +110,11 @@ public void Rollback()
         {
             CheckDisposed();
             var originalState = Interlocked.CompareExchange(ref _state, ROLLBACK, NONE);
-            if (originalState != NONE)
-            {
-                Debug.Assert(false, $"Trying rollback with state: {originalState}");
-                return;
-            }
-            _transaction!.Rollback();
+            Debug.Assert(originalState == NONE, $"Trying rollback with state: {originalState}");
+            Throw.InvalidOperationExceptionIf(originalState != NONE, $"Trying rollback with state: {originalState}");
+            _transaction.Rollback();
         }
 
         #endregion
-
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -10,33 +10,31 @@ partial class SQLiteDbConnection`
`10`	`10`	`public SQLiteDbTransaction BeginTransaction()`
`11`	`11`	`{`
`12`	`12`	`CheckDisposed();`
`13`		`- Debug.Assert(_inTransaction == 0);`
`14`		`- Interlocked.Increment(ref _inTransaction);`
	`13`	`+ Debug.Assert(TransactionCount == 0, "Transaction count should be zero before starting a new transaction.");`
	`14`	`+ Throw.InvalidOperationExceptionIf(InTransaction, "SQLite does not support nested transactions");`
`15`	`15`	`try`
`16`	`16`	`{`
`17`		`- return new SQLiteDbTransaction(this, _conn.BeginTransaction(), () => Interlocked.Decrement(ref _inTransaction));`
	`17`	`+ return new SQLiteDbTransaction(this, _conn.BeginTransaction());`
`18`	`18`	`}`
`19`	`19`	`catch (Exception ex)`
`20`	`20`	`{`
`21`	`21`	`Debug.Assert(_assertsDisabled, ex.GetType() + ": " + ex.Message);`
`22`		`- Interlocked.Decrement(ref _inTransaction);`
`23`	`22`	`throw;`
`24`	`23`	`}`
`25`	`24`	`}`
`26`	`25`
`27`	`26`	`public SQLiteDbTransaction BeginTransaction(IsolationLevel isolationLevel)`
`28`	`27`	`{`
`29`	`28`	`CheckDisposed();`
`30`		`- Debug.Assert(_inTransaction == 0);`
`31`		`- Interlocked.Increment(ref _inTransaction);`
	`29`	`+ Debug.Assert(TransactionCount == 0, "Transaction count should be zero before starting a new transaction.");`
	`30`	`+ Throw.InvalidOperationExceptionIf(InTransaction, "SQLite does not support nested transactions");`
`32`	`31`	`try`
`33`	`32`	`{`
`34`		`- return new SQLiteDbTransaction(this, _conn.BeginTransaction(isolationLevel), () => Interlocked.Decrement(ref _inTransaction));`
	`33`	`+ return new SQLiteDbTransaction(this, _conn.BeginTransaction(isolationLevel));`
`35`	`34`	`}`
`36`	`35`	`catch (Exception ex)`
`37`	`36`	`{`
`38`	`37`	`Debug.Assert(_assertsDisabled, ex.GetType() + ": " + ex.Message);`
`39`		`- Interlocked.Decrement(ref _inTransaction);`
`40`	`38`	`throw;`
`41`	`39`	`}`
`42`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public sealed partial class SQLiteDbConnection : Disposable, IDbConnection`
`14`	`14`	`{`
`15`	`15`	`private readonly SQLiteConnection _conn;`
`16`	`16`	`private SQLiteDbConnectionFactory.AsyncLockCounter _syncRoot;`
`17`		`- private volatile int _inTransaction;`
	`17`	`+ internal volatile int TransactionCount;`
`18`	`18`
`19`	`19`	`/// <summary>`
`20`	`20`	`/// Initializes the connection with the specified connection string.`
`@@ -37,12 +37,12 @@ public SQLiteDbConnection(string connectionString, bool useSharedLock)`
`37`	`37`	`#else`
`38`	`38`	`Throw.IfNullOrEmpty(connectionString);`
`39`	`39`	`#endif`
`40`		`- _ = new SQLiteConnectionStringBuilder(connectionString);//throws if connection string is invalid`
	`40`	`+ var csb = new SQLiteConnectionStringBuilder(connectionString);//throws if connection string is invalid`
`41`	`41`	`_conn = new SQLiteConnection(connectionString);`
`42`	`42`	`UseSharedLock = useSharedLock;`
`43`	`43`	`if (useSharedLock)`
`44`	`44`	`{`
`45`		`- _syncRoot = SQLiteDbConnectionFactory.Instance.GetSyncObj(connectionString);`
	`45`	`+ _syncRoot = SQLiteDbConnectionFactory.Instance.GetSyncObj(csb.DataSource);`
`46`	`46`	`}`
`47`	`47`	`else`
`48`	`48`	`{`
`@@ -66,7 +66,7 @@ public int DefaultTimeout`
`66`	`66`	`set => _conn.DefaultTimeout = value;`
`67`	`67`	`}`
`68`	`68`
`69`		`- public bool InTransaction => _inTransaction > 0;`
	`69`	`+ public bool InTransaction => TransactionCount > 0;`
`70`	`70`
`71`	`71`	`/// <summary>`
`72`	`72`	`/// Determines whether the current connection holds the database lock.`
`@@ -125,15 +125,14 @@ public void Close(ConnectionState originalState)`
`125`	`125`	`protected override void OnDispose()`
`126`	`126`	`{`
`127`	`127`	`Close();`
`128`		`- var connectionString = _conn.ConnectionString;`
`129`	`128`	`_conn.Dispose();`
`130`	`129`
`131`	`130`	`var syncRoot = Interlocked.Exchange(ref _syncRoot!, null);`
`132`	`131`	`if (syncRoot != null)`
`133`	`132`	`{`
`134`	`133`	`if (UseSharedLock)`
`135`	`134`	`{`
`136`		`- if (SQLiteDbConnectionFactory.Instance.TryRelease(connectionString))`
	`135`	`+ if (SQLiteDbConnectionFactory.Instance.TryRelease(syncRoot.DataSource!))`
`137`	`136`	`{`
`138`	`137`	`Debug.Assert(syncRoot.IsDisposed);`
`139`	`138`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,10 +6,11 @@ internal class SQLiteDbConnectionFactory`
`6`	`6`
`7`	`7`	`internal class AsyncLockCounter : Disposable`
`8`	`8`	`{`
`9`		`- public readonly ReentrantAsyncLock Mutex = new();`
`10`		`- public volatile int ReferenceCount;`
	`9`	`+ internal readonly ReentrantAsyncLock Mutex = new();`
	`10`	`+ internal volatile int ReferenceCount;`
	`11`	`+ internal string? DataSource;`
`11`	`12`	`#if DEBUG`
`12`		`- public bool IsExpired => ReferenceCount <= 0;`
	`13`	`+ internal bool IsExpired => ReferenceCount <= 0;`
`13`	`14`	`#endif`
`14`	`15`	`protected override void OnDispose()`
`15`	`16`	`{`
`@@ -43,28 +44,28 @@ private SQLiteDbConnectionFactory()`
`43`	`44`	`/// <summary>`
`44`	`45`	`/// Gets an object that can be used to synchronize access to the database.`
`45`	`46`	`/// </summary>`
`46`		`- internal AsyncLockCounter GetSyncObj(string connectionString)`
	`47`	`+ internal AsyncLockCounter GetSyncObj(string dataSource)`
`47`	`48`	`{`
`48`	`49`	`AsyncLockCounter? syncObject;`
`49`	`50`	`lock (_sharedLocks)`
`50`	`51`	`{`
`51`		`- if (!_sharedLocks.TryGetValue(connectionString, out syncObject))`
	`52`	`+ if (!_sharedLocks.TryGetValue(dataSource, out syncObject))`
`52`	`53`	`{`
`53`		`- _sharedLocks.Add(connectionString, syncObject = new AsyncLockCounter());`
	`54`	`+ _sharedLocks.Add(dataSource, syncObject = new AsyncLockCounter() { DataSource = dataSource });`
`54`	`55`	`}`
`55`	`56`	`Interlocked.Increment(ref syncObject.ReferenceCount);`
`56`	`57`	`}`
`57`	`58`	`return syncObject;`
`58`	`59`	`}`
`59`	`60`
`60`		`- internal bool TryRelease(string connectionString)`
	`61`	`+ internal bool TryRelease(string dataSource)`
`61`	`62`	`{`
`62`	`63`	`lock (_sharedLocks)`
`63`	`64`	`{`
`64`		`- if (_sharedLocks.TryGetValue(connectionString, out var syncObject) &&`
	`65`	`+ if (_sharedLocks.TryGetValue(dataSource, out var syncObject) &&`
`65`	`66`	`Interlocked.Decrement(ref syncObject.ReferenceCount) <= 0)`
`66`	`67`	`{`
`67`		`- _sharedLocks.Remove(connectionString);`
	`68`	`+ _sharedLocks.Remove(dataSource);`
`68`	`69`	`syncObject.Dispose();`
`69`	`70`	`return true;`
`70`	`71`	`}`