- SQLite restore holds every pool slot instead of the write lock first, removing a lock-order deadlock with sessions that begin to write. - PostgreSQL sessions always return their connection on dispose, a rollback while disposing never masks the original exception, and a busy session keeps its transaction until it is discarded. - The pool disposes a connection whose health check the caller cancels. - Listener commands keep their lock until the server answers and never tear a write with the caller's token; closing and pending no longer race. - Tag replacement locks the sequence and the tag row; unused-tag cleanup locks candidates and re-checks them with a fresh snapshot; render counts and stats refreshes lock the sequence row on PostgreSQL. - Sequence upserts keep rendered_count, which renders maintain. - AuthenticationOk after an unfinished SCRAM exchange is rejected. - Oversized read buffers are released; failed backups leave no .tmp; a zero idle lifetime is rejected. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
179 lines
8.7 KiB
C#
179 lines
8.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 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));
|
|
}
|