Increase delay to prevent busy. Prevent using config when no config option is used. Update config option to match doc.

Author: softlion

SQLite.Net.Tests/SQLite.Net2.Tests.csproj

@@ -6,6 +6,8 @@
     <IsPackable>false</IsPackable>
 
     <LangVersion>latest</LangVersion>
+
+    <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>

SQLite.Net.Tests/TransactionTest.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using NUnit.Framework;
 
 
@@ -51,7 +52,7 @@ public class TransactionTestException : Exception
         public class TestDb : SQLiteConnection
         {
             public TestDb(String path)
-                : base(path)
+                : base(path, busyTimeout: TimeSpan.FromSeconds(10))
             {
                 CreateTable<TestObj>();
             }
@@ -170,5 +171,55 @@ public void SuccesfulSavepointTransaction()
                 dbb.InsertOrReplaceAll(testObjects);
             });
         }
+        
+        [Test]
+        public async Task LockedTransaction()
+        {
+            var newObjects = Enumerable.Range(1, 1000000).Select(i => new TestObj()).ToList();
+
+            Exception? lastException = null;
+            var hasFinished = false;
+
+
+            var t1 = Task.Run(() =>
+            {
+                try
+                {
+                    db.InsertAll(newObjects);
+                }
+                catch (Exception e)
+                {
+                    lastException = e;
+                }
+
+                hasFinished = true;
+            });
+            
+            
+            var t2 = Task.Run(() =>
+            {
+                try
+                {
+                    for (var i = 0; i < 10000; i++)
+                    {
+                        _ = db.Table<TestObj>().ToList();
+                        if(hasFinished)
+                            break;
+                    }
+
+                    var obj = db.Table<TestObj>().FirstOrDefault(o => o.Id == 8);
+                    Assert.IsNotNull(obj);
+                    obj.Toto = 12;
+                    db.Update(obj);
+                }
+                catch (Exception e)
+                {
+                    lastException = e;
+                }
+            });
+
+            await Task.WhenAll(t1, t2);
+            Assert.IsNull(lastException, lastException?.Message);
+        }
     }
 }

nuget/pack.ps1

@@ -7,7 +7,7 @@ if ($IsMacOS) {
     $msbuild = join-path $msbuild 'MSBuild\Current\Bin\MSBuild.exe'
 }
 $version="2.1.0"
-$versionSuffix="-preA"
+$versionSuffix="-preB"
 
 #####################
 #Build release config

src/SQLite.Net/Interop/SQLiteOpenFlags.cs

@@ -24,19 +24,57 @@
 
 namespace SQLite.Net2
 {
+    /// <summary>
+    /// https://www.sqlite.org/c3ref/open.html
+    /// </summary>
     [Flags]
     public enum SQLiteOpenFlags
     {
         ReadOnly = 1,
         ReadWrite = 2,
         Create = 4,
+        
+        /// <summary>
+        /// The filename can be interpreted as a URI
+        /// See https://www.sqlite.org/c3ref/open.html
+        /// </summary>
+        OpenUri = 0x40,
+        /// <summary>
+        /// The database will be opened as an in-memory database. The database is named by the "filename" argument for the purposes of cache-sharing, if shared cache mode is enabled, but the "filename" is otherwise ignored.
+        /// </summary>
+        OpenMemory = 0x80,
+        
+        /// <summary>
+        /// The new database connection will use the "multi-thread" threading mode.
+        /// This means that separate threads are allowed to use SQLite at the same time, as long as each thread is using a different database connection.
+        /// </summary>
         NoMutex = 0x8000,
+        /// <summary>
+        /// The new database connection will use the "serialized" threading mode.
+        /// This means the multiple threads can safely attempt to use the same database connection at the same time.
+        /// (Mutexes will block any actual concurrency, but in this mode there is no harm in trying.)
+        /// </summary>
         FullMutex = 0x10000,
+        
         SharedCache = 0x20000,
         PrivateCache = 0x40000,
-        ProtectionComplete = 0x00100000,
-        ProtectionCompleteUnlessOpen = 0x00200000,
-        ProtectionCompleteUntilFirstUserAuthentication = 0x00300000,
-        ProtectionNone = 0x00400000
+
+        /// <summary>
+        /// The database filename is not allowed to be a symbolic link
+        /// </summary>
+        NoFollow = 0x100000,
+        /// <summary>
+        /// The database connection comes up in "extended result code mode". In other words, the database behaves has if sqlite3_extended_result_codes(db,1) where called on the database connection as soon as the connection is created. In addition to setting the extended result code mode, this flag also causes sqlite3_open_v2() to return an extended result code
+        /// </summary>
+        ExResCode = 0x02000000,
+        
+        [Obsolete]
+        ProtectionComplete = 0x100000,
+        [Obsolete]
+        ProtectionCompleteUnlessOpen = 0x200000,
+        [Obsolete]
+        ProtectionCompleteUntilFirstUserAuthentication = 0x300000,
+        [Obsolete]
+        ProtectionNone = 0x400000
     }
 }

src/SQLite.Net/SQLiteConnection.cs

@@ -114,7 +114,7 @@ public virtual SQLiteConnection Clone()
         /// <param name="busyTimeout">
         /// Sets a busy handler to sleep the specified amount of time when a table is locked.
         /// The handler will sleep multiple times until a total time of busyTimeout has accumulated.
-        /// Default to 1s
+        /// Default to 10s
         /// </param>
         public SQLiteConnection(string databasePath, SQLiteOpenFlags openFlags = SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create, bool storeDateTimeAsTicks = true,  IBlobSerializer? serializer = null,  IDictionary<string, TableMapping>? tableMappings = null,
              IDictionary<Type, string>? extraTypeMappings = null, IContractResolver? resolver = null, string? encryptionKey = null, ConfigOption configOption = ConfigOption.Serialized, TimeSpan? busyTimeout = null)
@@ -130,7 +130,9 @@ public SQLiteConnection(string databasePath, SQLiteOpenFlags openFlags = SQLiteO
                 if (configOption > ConfigOption.SingleThread && sqlite.Threadsafe() == 0)
                     throw new ArgumentException("SQlite is not compiled with multithread and config option is set to multithread", nameof(configOption));
 
-                sqlite.Config(configOption);
+                if(configOption > ConfigOption.Unknown)
+                    sqlite.Config(configOption);
+
                 sqlite.Initialize();
             }
 
@@ -154,7 +156,7 @@ public SQLiteConnection(string databasePath, SQLiteOpenFlags openFlags = SQLiteO
                     throw new Exception("Invalid cipher key");
             }
 
-            BusyTimeout = busyTimeout ?? TimeSpan.FromSeconds(1);
+            BusyTimeout = busyTimeout ?? TimeSpan.FromSeconds(10);
             Serializer = serializer;
             StoreDateTimeAsTicks = storeDateTimeAsTicks;
             ExtraTypeMappings = extraTypeMappings ?? new Dictionary<Type, string>();