SQLite steps ran synchronously on the calling thread, so a repository awaited on the WPF UI thread would freeze the window for the length of the query. Blocking calls now continue on the thread pool. A cancel that landed before sqlite3_step started the statement was lost (SQLite clears the interrupt when no statement is running) and the query ran to completion. Each connection now has a cancel flag polled by a progress handler; it is cleared outside every interruptible operation so a stale cancel cannot stop a later statement. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
199 lines
9.7 KiB
C#
199 lines
9.7 KiB
C#
using Titano.Data.Sqlite;
|
|
using Titano.Data.Tests.Infrastructure;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.Data.Tests.Sqlite;
|
|
|
|
public sealed class SqliteBindingTests(TestContext context) : DatabaseTest(context)
|
|
{
|
|
protected override Backend Backend => Backend.SqliteFile;
|
|
|
|
[Test]
|
|
public void SystemLibraryIsRecentEnough()
|
|
{
|
|
var parts = SqliteDatabase.LibraryVersion.Split('.').Select(int.Parse).ToArray();
|
|
Assert.True(parts[0] > 3 || (parts[0] == 3 && parts[1] >= 31), $"SQLite {SqliteDatabase.LibraryVersion}");
|
|
}
|
|
|
|
[Test]
|
|
public async Task ConnectionsUseTheBriefPragmas()
|
|
{
|
|
await using var session = await (await OpenDatabaseAsync()).OpenAsync(Ct);
|
|
Assert.Equal("wal", await session.ScalarAsync<string>("PRAGMA journal_mode", [], Ct));
|
|
Assert.Equal(1L, await session.ScalarAsync<long>("PRAGMA synchronous", [], Ct));
|
|
Assert.Equal(1L, await session.ScalarAsync<long>("PRAGMA foreign_keys", [], Ct));
|
|
Assert.Equal(2L, await session.ScalarAsync<long>("PRAGMA temp_store", [], Ct));
|
|
Assert.Equal(-65536L, await session.ScalarAsync<long>("PRAGMA cache_size", [], Ct));
|
|
Assert.Equal(268435456L, await session.ScalarAsync<long>("PRAGMA mmap_size", [], Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task CallsFromAUiThreadReturnBeforeTheStatementRuns()
|
|
{
|
|
await using var session = await (await OpenDatabaseAsync()).OpenAsync(Ct);
|
|
using var cts = CancellationTokenSource.CreateLinkedTokenSource(Ct);
|
|
Task? query = null;
|
|
var ui = new Thread(() =>
|
|
{
|
|
// A UI thread: has a synchronization context and is not a pool thread.
|
|
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
|
|
query = session.ExecuteAsync(
|
|
"WITH RECURSIVE r(n) AS (SELECT 1 UNION ALL SELECT n + 1 FROM r WHERE n < 2000000000) SELECT count(*) FROM r", [], cts.Token);
|
|
});
|
|
ui.Start();
|
|
Assert.True(ui.Join(TimeSpan.FromSeconds(5)), "the calling thread was blocked by the statement");
|
|
Assert.False(query!.IsCompleted);
|
|
await cts.CancelAsync();
|
|
await Assert.ThrowsAsync<OperationCanceledException>(() => query);
|
|
}
|
|
|
|
[Test]
|
|
public async Task RejectsScriptsAndWrongParameterCounts()
|
|
{
|
|
await using var session = await (await OpenDatabaseAsync()).OpenAsync(Ct);
|
|
await Assert.ThrowsAsync<ArgumentException>(() => session.ExecuteAsync("SELECT 1; SELECT 2", [], Ct));
|
|
await Assert.ThrowsAsync<ArgumentException>(() => session.ExecuteAsync("SELECT $1, $2", [1], Ct));
|
|
Assert.Equal(1, await session.ScalarAsync<int>("SELECT 1 -- trailing comment", [], Ct));
|
|
var error = await Assert.ThrowsAsync<SqliteException>(() => session.ExecuteAsync("SELEC 1", [], Ct));
|
|
Assert.Equal(1, error.ResultCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task WritersFromManySessionsAreSerialised()
|
|
{
|
|
var database = await OpenDatabaseAsync(multiConnection: true);
|
|
await using (var setup = await database.OpenAsync(Ct))
|
|
await setup.ExecuteScriptAsync("CREATE TABLE counter (id INTEGER PRIMARY KEY, n INTEGER NOT NULL); INSERT INTO counter VALUES (1, 0)", Ct);
|
|
|
|
await Task.WhenAll(Enumerable.Range(0, 8).Select(_ => Task.Run(async () =>
|
|
{
|
|
for (var i = 0; i < 25; i++)
|
|
{
|
|
await using var session = await database.OpenAsync(Ct);
|
|
await using var tx = await session.BeginAsync(Ct);
|
|
var n = await session.ScalarAsync<long>("SELECT n FROM counter WHERE id = 1", [], Ct);
|
|
await session.ExecuteAsync("UPDATE counter SET n = $1 WHERE id = 1", [n + 1], Ct);
|
|
await tx.CommitAsync(Ct);
|
|
}
|
|
})));
|
|
|
|
await using var check = await database.OpenAsync(Ct);
|
|
Assert.Equal(200L, await check.ScalarAsync<long>("SELECT n FROM counter", [], Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task ReadersSeeTheLastCommitWhileAWriterIsOpen()
|
|
{
|
|
var database = await OpenDatabaseAsync(multiConnection: true);
|
|
await using var writer = await database.OpenAsync(Ct);
|
|
await writer.ExecuteScriptAsync("CREATE TABLE r (id INTEGER PRIMARY KEY); INSERT INTO r VALUES (1)", Ct);
|
|
await using var tx = await writer.BeginAsync(Ct);
|
|
await writer.ExecuteAsync("INSERT INTO r VALUES ($1)", [2], Ct);
|
|
|
|
await using var reader = await database.OpenAsync(Ct);
|
|
Assert.Equal(1L, await reader.ScalarAsync<long>("SELECT count(*) FROM r", [], Ct));
|
|
await tx.CommitAsync(Ct);
|
|
Assert.Equal(2L, await reader.ScalarAsync<long>("SELECT count(*) FROM r", [], Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task SameStatementCanRunNestedOnOneSession()
|
|
{
|
|
await using var session = await (await OpenDatabaseAsync()).OpenAsync(Ct);
|
|
await session.ExecuteScriptAsync("CREATE TABLE r (id INTEGER PRIMARY KEY); INSERT INTO r VALUES (1); INSERT INTO r VALUES (2)", Ct);
|
|
var pairs = 0;
|
|
await foreach (var outer in session.QueryAsync("SELECT id FROM r ORDER BY id", [], Ct))
|
|
{
|
|
await foreach (var inner in session.QueryAsync("SELECT id FROM r ORDER BY id", [], Ct))
|
|
{
|
|
pairs++;
|
|
Assert.True(inner.GetInt32(0) is 1 or 2 && outer.GetInt32(0) is 1 or 2);
|
|
}
|
|
}
|
|
Assert.Equal(4, pairs);
|
|
}
|
|
|
|
[Test]
|
|
public async Task BackupKeepsTheThreeNewestAndRestoreBringsDataBack()
|
|
{
|
|
var path = Path.Combine(Context.CreateTempDirectory(), "titano.db");
|
|
var backups = Context.CreateTempDirectory();
|
|
var database = (SqliteDatabase)Own(DatabaseFactory.Open(DatabaseOptions.Sqlite(path)));
|
|
await using (var session = await database.OpenAsync(Ct))
|
|
await session.ExecuteScriptAsync("CREATE TABLE b (id INTEGER PRIMARY KEY, v TEXT); INSERT INTO b VALUES (1, 'original')", Ct);
|
|
|
|
var first = await database.BackupAsync(backups, cancellationToken: Ct);
|
|
Assert.FileExists(first);
|
|
for (var i = 0; i < 4; i++) await database.BackupAsync(backups, cancellationToken: Ct);
|
|
var kept = Directory.GetFiles(backups).OrderBy(f => f, StringComparer.Ordinal).ToList();
|
|
Assert.Equal(3, kept.Count);
|
|
Assert.DoesNotContain(first, kept);
|
|
|
|
await using (var session = await database.OpenAsync(Ct))
|
|
await session.ExecuteAsync("UPDATE b SET v = $1", ["changed"], Ct);
|
|
await database.RestoreAsync(kept[^1], Ct);
|
|
|
|
await using (var session = await database.OpenAsync(Ct))
|
|
Assert.Equal("original", await session.ScalarAsync<string>("SELECT v FROM b WHERE id = 1", [], Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task RestoreWaitsForSessionsThatStillWrite()
|
|
{
|
|
var path = Path.Combine(Context.CreateTempDirectory(), "titano.db");
|
|
var database = (SqliteDatabase)Own(DatabaseFactory.Open(DatabaseOptions.Sqlite(path)));
|
|
await using (var setup = await database.OpenAsync(Ct))
|
|
await setup.ExecuteScriptAsync("CREATE TABLE b (id INTEGER PRIMARY KEY)", Ct);
|
|
var backup = await database.BackupAsync(Context.CreateTempDirectory(), cancellationToken: Ct);
|
|
|
|
var session = await database.OpenAsync(Ct);
|
|
var restore = database.RestoreAsync(backup, Ct);
|
|
await Task.Delay(100, Ct);
|
|
Assert.False(restore.IsCompleted, "restore must wait for the open session");
|
|
// The session can still take the write lock while the restore waits for its pool slot.
|
|
await session.ExecuteAsync("INSERT INTO b VALUES ($1)", [1], Ct);
|
|
await using (var tx = await session.BeginAsync(Ct)) await tx.CommitAsync(Ct);
|
|
await session.DisposeAsync();
|
|
await restore.WaitAsync(TimeSpan.FromSeconds(10), Ct);
|
|
|
|
await using var check = await database.OpenAsync(Ct);
|
|
Assert.Equal(0L, await check.ScalarAsync<long>("SELECT count(*) FROM b", [], Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task RestoreRefusesAFileThatIsNotADatabase()
|
|
{
|
|
var database = (SqliteDatabase)await OpenDatabaseAsync();
|
|
var bogus = Path.Combine(Context.CreateTempDirectory(), "bogus.db");
|
|
await File.WriteAllTextAsync(bogus, "not a database, just text that is long enough to have a header", Ct);
|
|
await Assert.ThrowsAsync<InvalidDataException>(() => database.RestoreAsync(bogus, Ct));
|
|
await using var session = await database.OpenAsync(Ct);
|
|
Assert.Equal(1, await session.ScalarAsync<int>("SELECT 1", [], Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task InMemoryDatabasesAreIsolated()
|
|
{
|
|
var a = Own(DatabaseFactory.Open(DatabaseOptions.SqliteInMemory()));
|
|
var b = Own(DatabaseFactory.Open(DatabaseOptions.SqliteInMemory()));
|
|
await using (var s = await a.OpenAsync(Ct)) await s.ExecuteScriptAsync("CREATE TABLE only_a (id INTEGER)", Ct);
|
|
await using var sb = await b.OpenAsync(Ct);
|
|
Assert.Equal(0L, await sb.ScalarAsync<long>("SELECT count(*) FROM sqlite_master WHERE name = 'only_a'", [], Ct));
|
|
await Assert.ThrowsAsync<NotSupportedException>(() => ((SqliteDatabase)a).RestoreAsync("x.db", Ct));
|
|
}
|
|
}
|
|
|
|
public sealed class SqliteSqlTextTests
|
|
{
|
|
[Theory]
|
|
[Case("SELECT $1", "SELECT ?1")]
|
|
[Case("SELECT $2, $1, $12", "SELECT ?2, ?1, ?12")]
|
|
[Case("SELECT '$1', \"$2\", [$3], `$4` FROM t WHERE a = $5", "SELECT '$1', \"$2\", [$3], `$4` FROM t WHERE a = ?5")]
|
|
[Case("SELECT 'it''s $1' || $1", "SELECT 'it''s $1' || ?1")]
|
|
[Case("SELECT $1 -- $2\n, $3 /* $4 */", "SELECT ?1 -- $2\n, ?3 /* $4 */")]
|
|
[Case("SELECT a$1 FROM t", "SELECT a$1 FROM t")]
|
|
[Case("SELECT 'unterminated $1", "SELECT 'unterminated $1")]
|
|
public void TranslatesPlaceholdersOutsideLiterals(string sql, string expected) =>
|
|
Assert.Equal(expected, SqliteSqlText.TranslatePlaceholders(sql));
|
|
}
|