perf(localdb): dereg API, O(1) backlog depth, byte-budget batching, prepare-once apply (0.2.0)
WP3.3 of the ScadaBridge architectural-review remediation. Six changes, all wire-compatible with 0.1.x peers — no proto change, no lib_schema_version bump. The on-disk bookkeeping schema goes to v2 and is upgraded in place when a file is opened. DeregisterReplicated(table). There was no way to stop capturing once a file had been registered, so a node that does not replicate kept paying three triggers inside every write transaction, appending to an oplog nothing would ever drain. Drops the triggers and prunes the table's oplog + row-version rows in one transaction; idempotent, and deliberately usable on a table this process never registered, since stale triggers left by an EARLIER build are the primary case. Deregistration must be symmetric across a pair, and already is enforced: the handshake compares registered-table digests fail-closed, so a node that drops a table its peer still replicates stops syncing loudly rather than diverging. RegisterReplicated(table, baselineExistingRows: true). Closes the late-opt-in hole: the snapshot streamer pages from __localdb_row_version, which only triggers populate, so a node that started replicating LATE never sent its pre-existing rows — silently, forever. Seeding alone would not have fixed it, because a node whose oplog starts at seq 1 presents no gap at the handshake and is told it needs no snapshot; the seed therefore also flags needs_snapshot, and the existing resync machinery carries the rows. The floor is HLC 0 stamped with this node's id: every genuine HLC is a UTC millisecond shifted left 16 bits and so is strictly greater, which makes a baselined row lose every comparison against a real remote write and win only where the peer has no version of that key at all. Two nodes baselining the same key both hold 0 and resolve by the node-id tie-break — convergent, and nothing better is available for two rows of unordered antiquity. Opt-in, so the documented CDC contract is unchanged unless asked. Pruning the ledger on deregister is safe precisely because re-registration can re-baseline; the two APIs are a pair. O(1) backlog depth. GetOplogDepth ran COUNT(*) over the entire unacked backlog, once a minute from maintenance AND on every metrics scrape — a full scan of a million rows exactly when a node is already behind. Now MAX(seq) - MAX(last_acked_seq, MIN(seq) - 1), floored at 0: three b-tree seeks, measured at 58 VM steps against 100,020 for the count on a 50k backlog. Exact, because seq is AUTOINCREMENT and every prune path removes a prefix (ack pruning by watermark, the row cap by count, the age cap by an HLC cutoff that rises with seq). The MIN clamp is what keeps it exact after a cap prune has moved the horizon above a stalled watermark — without it the caps would re-flag on every tick forever. Byte-budget batching. MaxBatchSize was the only cap on an outbound message, which made it a proxy for a byte budget that consumers had to tune against their widest row: ScadaBridge pinned it to 16 because 70 KB config_json times the 500 default is ~35 MB against a 4 MB gRPC limit. MaxBatchBytes (default 2 MB) now bounds delta and snapshot messages by summed serialized size, with the row count demoted to a secondary cap. A row larger than the budget is sent alone rather than stalling the stream on it. Since more, smaller messages would otherwise mean more apply transactions and more acks, inbound delta batches and acks ALREADY queued are coalesced — one transaction and one ack per burst, bounded by the sender's own caps, and a no-op under a trickle. LwwApplier prepares each statement once. It went through the generic transaction façade, which builds a fresh SqliteCommand per call: three SQL parses per applied row, on the path that drains a reconnect backlog. Statements are now held for the batch and rebound. Dropped __localdb_oplog_hlc. It indexed (table_name, pk_json, hlc), which no query has ever used — every oplog access path is by seq or a full hlc-predicate delete — while costing a b-tree insert inside every captured consumer write. 184/184 tests pass (was 149). New coverage: schema upgrade drops the index and preserves identity/watermarks/data, deregistration idempotency and trigger absence and cross-process cleanup, baseline seeding at the floor with LWW safety proved through the real applier, depth asserted equal to the counting query across every prune scenario plus a constant-time assertion over a 200k backlog, byte-budget chunking including the one-giant-row edge on both the delta and snapshot paths, prepare-once statement counting, and coalescing that must not swallow the message that ends its run. Version 0.2.0.
This commit is contained in:
Joseph Doherty
@@ -0,0 +1,430 @@
|
||||
using System.Threading.Channels;
|
||||
using Microsoft.Data.Sqlite;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
using ZB.MOM.WW.LocalDb.Contracts;
|
||||
using ZB.MOM.WW.LocalDb.Internal;
|
||||
using ZB.MOM.WW.LocalDb.Replication;
|
||||
using ZB.MOM.WW.LocalDb.Replication.Internal;
|
||||
|
||||
namespace ZB.MOM.WW.LocalDb.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Outbound batching by summed serialized BYTES (with the row count kept as a secondary cap), and
|
||||
/// the inbound coalescing that keeps one transaction + one ack per burst rather than per message.
|
||||
/// </summary>
|
||||
public sealed class BatchBudgetTests : IDisposable
|
||||
{
|
||||
private static readonly TimeSpan RunTimeout = TimeSpan.FromSeconds(15);
|
||||
|
||||
private readonly List<string> _paths = [];
|
||||
private readonly List<IDisposable> _disposables = [];
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
foreach (var d in _disposables)
|
||||
d.Dispose();
|
||||
SqliteConnection.ClearAllPools();
|
||||
foreach (var p in _paths)
|
||||
{
|
||||
if (File.Exists(p)) File.Delete(p);
|
||||
if (File.Exists(p + "-wal")) File.Delete(p + "-wal");
|
||||
if (File.Exists(p + "-shm")) File.Delete(p + "-shm");
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<SqliteLocalDb> NewOrdersDbAsync()
|
||||
{
|
||||
var path = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".db");
|
||||
_paths.Add(path);
|
||||
var db = new SqliteLocalDb(new LocalDbOptions { Path = path });
|
||||
_disposables.Add(db);
|
||||
await db.ExecuteAsync("CREATE TABLE orders (id INTEGER PRIMARY KEY, sku TEXT, qty INTEGER)");
|
||||
db.RegisterReplicated("orders");
|
||||
return db;
|
||||
}
|
||||
|
||||
private static (SyncDuplex Duplex, ChannelWriter<SyncMessage> ToSession, ChannelReader<SyncMessage> FromSession) ScriptedPeer()
|
||||
{
|
||||
var toSession = Channel.CreateUnbounded<SyncMessage>();
|
||||
var fromSession = Channel.CreateUnbounded<SyncMessage>();
|
||||
var duplex = new SyncDuplex
|
||||
{
|
||||
Send = (m, ct) => fromSession.Writer.WriteAsync(m, ct).AsTask(),
|
||||
Inbox = toSession.Reader,
|
||||
};
|
||||
return (duplex, toSession.Writer, fromSession.Reader);
|
||||
}
|
||||
|
||||
private static Handshake MatchingHandshake(SqliteLocalDb sessionDb, string peerNodeId)
|
||||
{
|
||||
var h = new Handshake { NodeId = peerNodeId, LibSchemaVersion = 1, LastAppliedRemoteSeq = 0 };
|
||||
foreach (var t in sessionDb.ReplicatedTables.Values.OrderBy(t => t.Name, StringComparer.Ordinal))
|
||||
h.Tables.Add(new TableDigest { TableName = t.Name, Digest = t.Digest });
|
||||
return h;
|
||||
}
|
||||
|
||||
private static async Task<SyncMessage> NextAsync(ChannelReader<SyncMessage> reader, CancellationToken ct)
|
||||
{
|
||||
await reader.WaitToReadAsync(ct);
|
||||
reader.TryRead(out var msg);
|
||||
return msg!;
|
||||
}
|
||||
|
||||
private static async Task SwallowAsync(Task task)
|
||||
{
|
||||
try { await task; }
|
||||
catch (OperationCanceledException) { }
|
||||
}
|
||||
|
||||
// Queues a complete peer handshake AHEAD of the session's own, so anything queued after it is
|
||||
// guaranteed to be sitting in the inbox by the time the receive loop starts. That is what makes
|
||||
// the coalescing assertions deterministic rather than a race with the reader.
|
||||
private static async Task PreloadHandshakeAsync(
|
||||
SqliteLocalDb db, ChannelWriter<SyncMessage> toSession, CancellationToken ct)
|
||||
{
|
||||
await toSession.WriteAsync(new SyncMessage { Handshake = MatchingHandshake(db, "peer") }, ct);
|
||||
await toSession.WriteAsync(
|
||||
new SyncMessage { HandshakeAck = new HandshakeAck { NodeId = "peer", SnapshotRequired = false } }, ct);
|
||||
}
|
||||
|
||||
private static long BatchBytes(DeltaBatch batch) =>
|
||||
batch.Entries.Sum(e => 1L + Google.Protobuf.CodedOutputStream.ComputeMessageSize(e));
|
||||
|
||||
private static long BatchBytes(SnapshotBatch batch) =>
|
||||
batch.Rows.Sum(r => 1L + Google.Protobuf.CodedOutputStream.ComputeMessageSize(r));
|
||||
|
||||
private static SyncSession NewSession(SqliteLocalDb db, ReplicationOptions options)
|
||||
{
|
||||
var store = new OplogStore(db, options);
|
||||
var applier = new LwwApplier(db);
|
||||
return new SyncSession(db, store, applier, options, NullLogger.Instance);
|
||||
}
|
||||
|
||||
private static OplogEntry ProtoEntry(long seq, long id, long hlc) =>
|
||||
new()
|
||||
{
|
||||
Seq = seq,
|
||||
TableName = "orders",
|
||||
PkJson = $"{{\"id\":{id}}}",
|
||||
RowJson = $"{{\"id\":{id},\"sku\":\"S\",\"qty\":1}}",
|
||||
Hlc = hlc,
|
||||
NodeId = "peer",
|
||||
IsTombstone = false,
|
||||
};
|
||||
|
||||
// ---- Outbound: delta pump --------------------------------------------------------------
|
||||
|
||||
[Fact]
|
||||
public async Task Pump_SplitsOneReadIntoSeveralMessages_EachWithinTheByteBudget()
|
||||
{
|
||||
const int budget = 4_000;
|
||||
var db = await NewOrdersDbAsync();
|
||||
var wide = new string('x', 900);
|
||||
for (var i = 1; i <= 20; i++)
|
||||
await db.ExecuteAsync(
|
||||
"INSERT INTO orders (id, sku, qty) VALUES (@id, @sku, @id)", new { id = i, sku = wide });
|
||||
|
||||
// Row count alone would put all 20 wide rows (~18 KB) in ONE message; the byte budget is
|
||||
// what actually bounds the message the transport has to carry.
|
||||
var options = new ReplicationOptions
|
||||
{
|
||||
FlushInterval = TimeSpan.FromMilliseconds(20), MaxBatchSize = 500, MaxBatchBytes = budget,
|
||||
};
|
||||
var session = NewSession(db, options);
|
||||
var (duplex, toSession, fromSession) = ScriptedPeer();
|
||||
|
||||
using var cts = new CancellationTokenSource(RunTimeout);
|
||||
var run = session.RunAsync(duplex, cts.Token);
|
||||
await PreloadHandshakeAsync(db, toSession, cts.Token);
|
||||
|
||||
var seen = new List<long>();
|
||||
while (seen.Count < 20)
|
||||
{
|
||||
var msg = await NextAsync(fromSession, cts.Token);
|
||||
if (msg.MsgCase != SyncMessage.MsgOneofCase.DeltaBatch)
|
||||
continue;
|
||||
Assert.True(BatchBytes(msg.DeltaBatch) <= budget,
|
||||
$"a {BatchBytes(msg.DeltaBatch)}-byte message exceeded the {budget}-byte budget");
|
||||
Assert.True(msg.DeltaBatch.Entries.Count > 1, "the budget should still fit several of these rows");
|
||||
seen.AddRange(msg.DeltaBatch.Entries.Select(e => e.Seq));
|
||||
}
|
||||
|
||||
// Split, not dropped or duplicated: every captured seq travelled exactly once, in order.
|
||||
Assert.Equal(20, seen.Count);
|
||||
Assert.Equal(seen.OrderBy(x => x).ToList(), seen);
|
||||
Assert.Equal(20, seen.Distinct().Count());
|
||||
|
||||
cts.Cancel();
|
||||
await SwallowAsync(run);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Pump_RowLargerThanTheBudget_IsSentAloneRatherThanStallingTheStream()
|
||||
{
|
||||
var db = await NewOrdersDbAsync();
|
||||
await db.ExecuteAsync(
|
||||
"INSERT INTO orders (id, sku, qty) VALUES (1, @sku, 1)", new { sku = new string('x', 5_000) });
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (2, 'small', 2)");
|
||||
|
||||
var options = new ReplicationOptions
|
||||
{
|
||||
FlushInterval = TimeSpan.FromMilliseconds(20), MaxBatchSize = 500, MaxBatchBytes = 100,
|
||||
};
|
||||
var session = NewSession(db, options);
|
||||
var (duplex, toSession, fromSession) = ScriptedPeer();
|
||||
|
||||
using var cts = new CancellationTokenSource(RunTimeout);
|
||||
var run = session.RunAsync(duplex, cts.Token);
|
||||
await PreloadHandshakeAsync(db, toSession, cts.Token);
|
||||
|
||||
var batches = new List<DeltaBatch>();
|
||||
while (batches.Sum(b => b.Entries.Count) < 2)
|
||||
{
|
||||
var msg = await NextAsync(fromSession, cts.Token);
|
||||
if (msg.MsgCase == SyncMessage.MsgOneofCase.DeltaBatch)
|
||||
batches.Add(msg.DeltaBatch);
|
||||
}
|
||||
|
||||
// The oversized row goes out on its own — refusing it would wedge the stream on one row
|
||||
// forever, and everything behind it with it.
|
||||
Assert.Equal(2, batches.Count);
|
||||
Assert.Single(batches[0].Entries);
|
||||
Assert.Equal(1, batches[0].Entries[0].Seq);
|
||||
Assert.True(BatchBytes(batches[0]) > options.MaxBatchBytes);
|
||||
Assert.Single(batches[1].Entries);
|
||||
Assert.Equal(2, batches[1].Entries[0].Seq);
|
||||
|
||||
cts.Cancel();
|
||||
await SwallowAsync(run);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Pump_RowCountRemainsASecondaryCap()
|
||||
{
|
||||
var db = await NewOrdersDbAsync();
|
||||
for (var i = 1; i <= 12; i++)
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (@id, 'S', @id)", new { id = i });
|
||||
|
||||
// Tiny rows, enormous byte budget: only the row cap can be doing the splitting here.
|
||||
var options = new ReplicationOptions
|
||||
{
|
||||
FlushInterval = TimeSpan.FromMilliseconds(20), MaxBatchSize = 5, MaxBatchBytes = 8 * 1024 * 1024,
|
||||
};
|
||||
var session = NewSession(db, options);
|
||||
var (duplex, toSession, fromSession) = ScriptedPeer();
|
||||
|
||||
using var cts = new CancellationTokenSource(RunTimeout);
|
||||
var run = session.RunAsync(duplex, cts.Token);
|
||||
await PreloadHandshakeAsync(db, toSession, cts.Token);
|
||||
|
||||
var seen = 0;
|
||||
while (seen < 12)
|
||||
{
|
||||
var msg = await NextAsync(fromSession, cts.Token);
|
||||
if (msg.MsgCase != SyncMessage.MsgOneofCase.DeltaBatch)
|
||||
continue;
|
||||
Assert.True(msg.DeltaBatch.Entries.Count <= 5);
|
||||
seen += msg.DeltaBatch.Entries.Count;
|
||||
}
|
||||
|
||||
cts.Cancel();
|
||||
await SwallowAsync(run);
|
||||
}
|
||||
|
||||
// ---- Outbound: snapshot --------------------------------------------------------------
|
||||
|
||||
[Fact]
|
||||
public async Task Snapshot_SplitsPagesIntoMessagesWithinTheByteBudget()
|
||||
{
|
||||
const int budget = 4_000;
|
||||
var db = await NewOrdersDbAsync();
|
||||
var wide = new string('x', 900);
|
||||
for (var i = 1; i <= 20; i++)
|
||||
await db.ExecuteAsync(
|
||||
"INSERT INTO orders (id, sku, qty) VALUES (@id, @sku, @id)", new { id = i, sku = wide });
|
||||
|
||||
// A snapshot is the easiest way to blow a message limit: it ships whole rows, all of them,
|
||||
// back to back — so its page size has to be bounded in bytes too, not just in rows.
|
||||
var options = new ReplicationOptions { MaxBatchSize = 500, MaxBatchBytes = budget };
|
||||
var store = new OplogStore(db, options);
|
||||
var streamer = new SnapshotStreamer(db, store, options, NullLogger.Instance);
|
||||
|
||||
var sent = new List<SyncMessage>();
|
||||
await streamer.SendAsync((m, _) => { sent.Add(m); return Task.CompletedTask; }, default);
|
||||
|
||||
var batches = sent.Where(m => m.MsgCase == SyncMessage.MsgOneofCase.SnapshotBatch)
|
||||
.Select(m => m.SnapshotBatch).ToList();
|
||||
Assert.True(batches.Count > 1, "20 wide rows must not have travelled as one message");
|
||||
Assert.All(batches, b => Assert.True(BatchBytes(b) <= budget,
|
||||
$"a {BatchBytes(b)}-byte snapshot message exceeded the {budget}-byte budget"));
|
||||
|
||||
// Bracketed and complete: every row, exactly once.
|
||||
Assert.Equal(SyncMessage.MsgOneofCase.SnapshotBegin, sent[0].MsgCase);
|
||||
Assert.Equal(SyncMessage.MsgOneofCase.SnapshotComplete, sent[^1].MsgCase);
|
||||
var pks = batches.SelectMany(b => b.Rows).Select(r => r.PkJson).ToList();
|
||||
Assert.Equal(20, pks.Count);
|
||||
Assert.Equal(20, pks.Distinct().Count());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Snapshot_RowLargerThanTheBudget_IsSentAlone()
|
||||
{
|
||||
var db = await NewOrdersDbAsync();
|
||||
await db.ExecuteAsync(
|
||||
"INSERT INTO orders (id, sku, qty) VALUES (1, @sku, 1)", new { sku = new string('x', 5_000) });
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (2, 'small', 2)");
|
||||
|
||||
var options = new ReplicationOptions { MaxBatchSize = 500, MaxBatchBytes = 100 };
|
||||
var store = new OplogStore(db, options);
|
||||
var streamer = new SnapshotStreamer(db, store, options, NullLogger.Instance);
|
||||
|
||||
var sent = new List<SyncMessage>();
|
||||
await streamer.SendAsync((m, _) => { sent.Add(m); return Task.CompletedTask; }, default);
|
||||
|
||||
var batches = sent.Where(m => m.MsgCase == SyncMessage.MsgOneofCase.SnapshotBatch)
|
||||
.Select(m => m.SnapshotBatch).ToList();
|
||||
Assert.Equal(2, batches.Count);
|
||||
Assert.All(batches, b => Assert.Single(b.Rows));
|
||||
Assert.Equal("{\"id\":1}", batches[0].Rows[0].PkJson);
|
||||
Assert.Equal("{\"id\":2}", batches[1].Rows[0].PkJson);
|
||||
}
|
||||
|
||||
// ---- Inbound: coalescing -------------------------------------------------------------
|
||||
|
||||
[Fact]
|
||||
public async Task Receive_CoalescesQueuedDeltaBatches_IntoOneAck()
|
||||
{
|
||||
var db = await NewOrdersDbAsync();
|
||||
var options = new ReplicationOptions { FlushInterval = TimeSpan.FromSeconds(30) };
|
||||
var session = NewSession(db, options);
|
||||
var (duplex, toSession, fromSession) = ScriptedPeer();
|
||||
|
||||
using var cts = new CancellationTokenSource(RunTimeout);
|
||||
var run = session.RunAsync(duplex, cts.Token);
|
||||
|
||||
// Queued ahead of the receive loop, so all three are demonstrably in the inbox together.
|
||||
await PreloadHandshakeAsync(db, toSession, cts.Token);
|
||||
for (var i = 1; i <= 3; i++)
|
||||
{
|
||||
var batch = new DeltaBatch();
|
||||
batch.Entries.Add(ProtoEntry(i, i, 1_000_000 + i));
|
||||
await toSession.WriteAsync(new SyncMessage { DeltaBatch = batch }, cts.Token);
|
||||
}
|
||||
|
||||
SyncMessage ack;
|
||||
do { ack = await NextAsync(fromSession, cts.Token); }
|
||||
while (ack.MsgCase != SyncMessage.MsgOneofCase.DeltaAck);
|
||||
|
||||
// The discriminator: uncoalesced, the FIRST ack could only cover seq 1.
|
||||
Assert.Equal(3, ack.DeltaAck.AppliedThruSeq);
|
||||
|
||||
var rows = await db.QueryAsync("SELECT COUNT(*) FROM orders", r => r.GetInt64(0));
|
||||
Assert.Equal(3, rows[0]);
|
||||
|
||||
cts.Cancel();
|
||||
await SwallowAsync(run);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Receive_DeltaCoalescing_DoesNotSwallowTheMessageThatEndsTheRun()
|
||||
{
|
||||
// The risk the one-message lookahead exists to handle: coalescing reads ahead, and whatever
|
||||
// it reads that is NOT a delta must still be processed, not dropped on the floor.
|
||||
var db = await NewOrdersDbAsync();
|
||||
var options = new ReplicationOptions { FlushInterval = TimeSpan.FromSeconds(30) };
|
||||
var session = NewSession(db, options);
|
||||
var captured = new CapturingSnapshotApplier();
|
||||
session.SnapshotApplier = captured;
|
||||
var (duplex, toSession, fromSession) = ScriptedPeer();
|
||||
|
||||
using var cts = new CancellationTokenSource(RunTimeout);
|
||||
var run = session.RunAsync(duplex, cts.Token);
|
||||
|
||||
await PreloadHandshakeAsync(db, toSession, cts.Token);
|
||||
var batch = new DeltaBatch();
|
||||
batch.Entries.Add(ProtoEntry(1, 1, 1_000_001));
|
||||
await toSession.WriteAsync(new SyncMessage { DeltaBatch = batch }, cts.Token);
|
||||
await toSession.WriteAsync(
|
||||
new SyncMessage { SnapshotBegin = new SnapshotBegin { AsOfSeq = 77 } }, cts.Token);
|
||||
|
||||
SyncMessage ack;
|
||||
do { ack = await NextAsync(fromSession, cts.Token); }
|
||||
while (ack.MsgCase != SyncMessage.MsgOneofCase.DeltaAck);
|
||||
Assert.Equal(1, ack.DeltaAck.AppliedThruSeq);
|
||||
|
||||
// The SnapshotBegin that terminated the coalescing run still reached its handler.
|
||||
await WaitForAsync(() => captured.BeginAsOfSeq == 77, RunTimeout);
|
||||
|
||||
cts.Cancel();
|
||||
await SwallowAsync(run);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Receive_CoalescesQueuedAcks_ToTheHighestWatermark_WithoutLosingTheNextMessage()
|
||||
{
|
||||
var db = await NewOrdersDbAsync();
|
||||
for (var i = 1; i <= 9; i++)
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (@id, 'S', @id)", new { id = i });
|
||||
|
||||
var options = new ReplicationOptions { FlushInterval = TimeSpan.FromSeconds(30) };
|
||||
var session = NewSession(db, options);
|
||||
var captured = new CapturingSnapshotApplier();
|
||||
session.SnapshotApplier = captured;
|
||||
var (duplex, toSession, fromSession) = ScriptedPeer();
|
||||
|
||||
using var cts = new CancellationTokenSource(RunTimeout);
|
||||
var run = session.RunAsync(duplex, cts.Token);
|
||||
|
||||
await PreloadHandshakeAsync(db, toSession, cts.Token);
|
||||
// Out of order on purpose: collapsing acks must take the MAX, never the last.
|
||||
foreach (var seq in new long[] { 4, 9, 2 })
|
||||
await toSession.WriteAsync(
|
||||
new SyncMessage { DeltaAck = new DeltaAck { AppliedThruSeq = seq } }, cts.Token);
|
||||
await toSession.WriteAsync(
|
||||
new SyncMessage { SnapshotBegin = new SnapshotBegin { AsOfSeq = 55 } }, cts.Token);
|
||||
|
||||
await WaitForAsync(async () =>
|
||||
{
|
||||
var acked = await db.QueryAsync(
|
||||
"SELECT last_acked_seq FROM __localdb_peer_state WHERE id = 1", r => r.GetInt64(0));
|
||||
return acked[0] == 9;
|
||||
}, RunTimeout);
|
||||
|
||||
Assert.Equal(9, session.PeerAckedSeq);
|
||||
await WaitForAsync(() => captured.BeginAsOfSeq == 55, RunTimeout);
|
||||
|
||||
cts.Cancel();
|
||||
await SwallowAsync(run);
|
||||
}
|
||||
|
||||
private sealed class CapturingSnapshotApplier : ISnapshotApplier
|
||||
{
|
||||
private long _beginAsOfSeq = -1;
|
||||
|
||||
public long BeginAsOfSeq => Interlocked.Read(ref _beginAsOfSeq);
|
||||
|
||||
public Task OnBeginAsync(SnapshotBegin begin, CancellationToken ct)
|
||||
{
|
||||
Interlocked.Exchange(ref _beginAsOfSeq, begin.AsOfSeq);
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public Task OnBatchAsync(SnapshotBatch batch, CancellationToken ct) => Task.CompletedTask;
|
||||
|
||||
public Task OnCompleteAsync(SnapshotComplete complete, CancellationToken ct) => Task.CompletedTask;
|
||||
}
|
||||
|
||||
private static Task WaitForAsync(Func<bool> predicate, TimeSpan timeout) =>
|
||||
WaitForAsync(() => Task.FromResult(predicate()), timeout);
|
||||
|
||||
private static async Task WaitForAsync(Func<Task<bool>> predicate, TimeSpan timeout)
|
||||
{
|
||||
var deadline = DateTime.UtcNow + timeout;
|
||||
while (DateTime.UtcNow < deadline)
|
||||
{
|
||||
if (await predicate()) return;
|
||||
await Task.Delay(20);
|
||||
}
|
||||
throw new TimeoutException("Condition not reached within " + timeout);
|
||||
}
|
||||
}
|
||||
@@ -55,8 +55,75 @@ public sealed class LocalDbSchemaTests : IDisposable
|
||||
})
|
||||
Assert.Contains(expected, tables);
|
||||
|
||||
// __localdb_oplog_hlc is deliberately NOT created: schema v2 removed it. It indexed
|
||||
// (table_name, pk_json, hlc), which no query has ever used — every oplog access path is by
|
||||
// seq or a full hlc-predicate delete — while costing a b-tree insert inside every captured
|
||||
// consumer write.
|
||||
Assert.Equal(0, ScalarLong(conn,
|
||||
"SELECT count(*) FROM sqlite_master WHERE type='index' AND name='__localdb_oplog_hlc'"));
|
||||
Assert.Equal(LocalDbSchema.CurrentSchemaVersion,
|
||||
ScalarLong(conn, "SELECT schema_version FROM __localdb_meta WHERE id=1"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EnsureCreated_UpgradesLegacyFile_DropsOplogHlcIndex()
|
||||
{
|
||||
using var conn = Open();
|
||||
|
||||
// A file exactly as schema v1 left it: the tables, the index, and a v1 stamp.
|
||||
LocalDbSchema.EnsureCreated(conn);
|
||||
Exec(conn, "CREATE INDEX __localdb_oplog_hlc ON __localdb_oplog(table_name, pk_json, hlc);" +
|
||||
"UPDATE __localdb_meta SET schema_version = 1 WHERE id = 1;");
|
||||
Assert.Equal(1, ScalarLong(conn,
|
||||
"SELECT count(*) FROM sqlite_master WHERE type='index' AND name='__localdb_oplog_hlc'"));
|
||||
|
||||
LocalDbSchema.EnsureCreated(conn);
|
||||
|
||||
Assert.Equal(0, ScalarLong(conn,
|
||||
"SELECT count(*) FROM sqlite_master WHERE type='index' AND name='__localdb_oplog_hlc'"));
|
||||
Assert.Equal(LocalDbSchema.CurrentSchemaVersion,
|
||||
ScalarLong(conn, "SELECT schema_version FROM __localdb_meta WHERE id=1"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EnsureCreated_Upgrade_PreservesNodeIdentityAndOplogRows()
|
||||
{
|
||||
using var conn = Open();
|
||||
LocalDbSchema.EnsureCreated(conn);
|
||||
var nodeId = ScalarString(conn, "SELECT node_id FROM __localdb_meta WHERE id=1");
|
||||
Exec(conn,
|
||||
"CREATE INDEX __localdb_oplog_hlc ON __localdb_oplog(table_name, pk_json, hlc);" +
|
||||
"UPDATE __localdb_meta SET schema_version = 1 WHERE id = 1;" +
|
||||
"INSERT INTO __localdb_oplog (table_name, pk_json, row_json, hlc, node_id, is_tombstone) " +
|
||||
"VALUES ('orders', '{\"id\":1}', '{\"id\":1}', 42, 'n', 0);" +
|
||||
"UPDATE __localdb_peer_state SET last_acked_seq = 7 WHERE id = 1;");
|
||||
|
||||
LocalDbSchema.EnsureCreated(conn);
|
||||
|
||||
// The upgrade is DDL only — identity, replication watermarks and captured data survive it.
|
||||
Assert.Equal(nodeId, ScalarString(conn, "SELECT node_id FROM __localdb_meta WHERE id=1"));
|
||||
Assert.Equal(1, ScalarLong(conn, "SELECT COUNT(*) FROM __localdb_oplog"));
|
||||
Assert.Equal(42, ScalarLong(conn, "SELECT hlc FROM __localdb_oplog"));
|
||||
Assert.Equal(7, ScalarLong(conn, "SELECT last_acked_seq FROM __localdb_peer_state WHERE id=1"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EnsureCreated_AlreadyCurrent_LeavesVersionAlone()
|
||||
{
|
||||
using var conn = Open();
|
||||
LocalDbSchema.EnsureCreated(conn);
|
||||
LocalDbSchema.EnsureCreated(conn);
|
||||
LocalDbSchema.EnsureCreated(conn);
|
||||
|
||||
Assert.Equal(LocalDbSchema.CurrentSchemaVersion,
|
||||
ScalarLong(conn, "SELECT schema_version FROM __localdb_meta WHERE id=1"));
|
||||
}
|
||||
|
||||
private static void Exec(SqliteConnection conn, string sql)
|
||||
{
|
||||
using var cmd = conn.CreateCommand();
|
||||
cmd.CommandText = sql;
|
||||
cmd.ExecuteNonQuery();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
||||
@@ -404,6 +404,64 @@ public sealed class LwwApplierTests : IDisposable
|
||||
Assert.Equal(("NEW", (long?)7), await ReadOrder(db, 2));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Apply_PreparesEachStatementOnce_NotOncePerRow()
|
||||
{
|
||||
// The regression this guards: the old shape went through the generic transaction façade,
|
||||
// which builds a fresh SqliteCommand — and therefore re-parses the SQL — per call. Three
|
||||
// statements per applied row means a 200-row batch parsed 600 statements to run 6 distinct
|
||||
// ones. Statement count must track distinct SQL, not rows.
|
||||
using var db = await NewOrdersDb();
|
||||
await db.ExecuteAsync("CREATE TABLE widgets (id INTEGER PRIMARY KEY, name TEXT)");
|
||||
db.RegisterReplicated("widgets");
|
||||
|
||||
var entries = new List<OplogEntryRecord>();
|
||||
for (var i = 1; i <= 200; i++)
|
||||
entries.Add(Entry(i, $"{{\"id\":{i}}}", $"{{\"id\":{i},\"sku\":\"S\",\"qty\":{i}}}", 1_000_000 + i, "remote"));
|
||||
// A second table and a tombstone, so every statement kind in the set is exercised.
|
||||
entries.Add(new OplogEntryRecord(
|
||||
201, "widgets", "{\"id\":1}", "{\"id\":1,\"name\":\"W\"}", 1_000_300, "remote", false));
|
||||
entries.Add(Entry(202, "{\"id\":1}", null, 1_000_400, "remote", tombstone: true));
|
||||
|
||||
var applier = new LwwApplier(db);
|
||||
var result = await applier.ApplyBatchAsync(entries, default);
|
||||
|
||||
Assert.Equal(202, result.Applied);
|
||||
// Four table-independent statements (applying guard, version lookup, row-version write,
|
||||
// peer state), plus an upsert per table touched and a delete for the one table tombstoned.
|
||||
Assert.Equal(7, applier.LastBatchStatementCount);
|
||||
|
||||
// ...and the batch is still correct, statement reuse notwithstanding.
|
||||
Assert.Null(await ReadOrder(db, 1));
|
||||
Assert.Equal(("S", (long?)200), await ReadOrder(db, 200));
|
||||
var widget = await db.QueryAsync("SELECT name FROM widgets WHERE id = 1", x => x.GetString(0));
|
||||
Assert.Equal("W", widget[0]);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Apply_ReusedStatements_SurviveAPoisonRowMidBatch()
|
||||
{
|
||||
// A statement that faults is reset and reused for the following rows; if it were not, one
|
||||
// poison row would silently corrupt every row after it in the batch.
|
||||
using var db = await NewOrdersDb();
|
||||
|
||||
var applier = new LwwApplier(db);
|
||||
var result = await applier.ApplyBatchAsync(
|
||||
[
|
||||
Entry(1, "{\"id\":1}", "{\"id\":1,\"sku\":\"BEFORE\",\"qty\":1}", 1_000_000, "remote"),
|
||||
Entry(2, "{\"id\":2}", "NOT VALID JSON", 1_000_001, "remote"),
|
||||
Entry(3, "{\"id\":3}", "{\"id\":3,\"sku\":\"AFTER\",\"qty\":3}", 1_000_002, "remote"),
|
||||
Entry(4, "{\"id\":4}", "ALSO NOT JSON", 1_000_003, "remote"),
|
||||
Entry(5, "{\"id\":5}", "{\"id\":5,\"sku\":\"LAST\",\"qty\":5}", 1_000_004, "remote"),
|
||||
], default);
|
||||
|
||||
Assert.Equal(3, result.Applied);
|
||||
Assert.Equal(2, result.DeadLettered);
|
||||
Assert.Equal(("BEFORE", (long?)1), await ReadOrder(db, 1));
|
||||
Assert.Equal(("AFTER", (long?)3), await ReadOrder(db, 3));
|
||||
Assert.Equal(("LAST", (long?)5), await ReadOrder(db, 5));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Apply_ReplaceExistingRow_DoesNotFireCaptureTriggers()
|
||||
{
|
||||
|
||||
@@ -212,6 +212,137 @@ public sealed class OplogStoreTests : IDisposable
|
||||
Assert.Equal("{\"id\":2}", remaining[0].PkJson);
|
||||
}
|
||||
|
||||
// ---- O(1) backlog depth --------------------------------------------------------------
|
||||
|
||||
// The definition the O(1) formula has to reproduce. Every scenario below is asserted against
|
||||
// this, not against a hand-computed number, so the two can never drift apart.
|
||||
private static async Task<long> CountingDepth(SqliteLocalDb db) =>
|
||||
(await db.QueryAsync(
|
||||
"SELECT COUNT(*) FROM __localdb_oplog WHERE seq > (SELECT last_acked_seq FROM __localdb_peer_state WHERE id = 1)",
|
||||
r => r.GetInt64(0)))[0];
|
||||
|
||||
private static async Task AssertDepthMatchesCount(SqliteLocalDb db, OplogStore store)
|
||||
{
|
||||
var expected = await CountingDepth(db);
|
||||
Assert.Equal(expected, await store.GetOplogDepthAsync(default));
|
||||
Assert.Equal(expected, store.GetOplogDepthSync());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task OplogDepth_Empty_IsZero()
|
||||
{
|
||||
using var db = await NewOrdersDb();
|
||||
var store = new OplogStore(db, new ReplicationOptions());
|
||||
|
||||
await AssertDepthMatchesCount(db, store);
|
||||
Assert.Equal(0, await store.GetOplogDepthAsync(default));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task OplogDepth_AllAcked_EmptiesToZero_NotToTheSeqRange()
|
||||
{
|
||||
using var db = await NewOrdersDb();
|
||||
await WriteRows(db, 5);
|
||||
var store = new OplogStore(db, new ReplicationOptions());
|
||||
await store.RecordPeerAckAsync(await store.GetMaxSeqAsync(default), default);
|
||||
|
||||
await AssertDepthMatchesCount(db, store);
|
||||
Assert.Equal(0, await store.GetOplogDepthAsync(default));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task OplogDepth_AfterCapPrune_ReportsRetainedRows_NotTheWholeSeqRange()
|
||||
{
|
||||
// The reason the formula clamps its floor to MIN(seq) - 1. A cap prune leaves the retained
|
||||
// rows far above an ack watermark that never moved, so a naive MAX(seq) - last_acked would
|
||||
// report the entire seq range forever and re-flag the cap on every maintenance tick.
|
||||
using var db = await NewOrdersDb();
|
||||
await WriteRows(db, 40);
|
||||
var store = new OplogStore(db, new ReplicationOptions { MaxOplogRows = 5 });
|
||||
|
||||
Assert.True(await store.EnforceCapsAsync(default));
|
||||
|
||||
await AssertDepthMatchesCount(db, store);
|
||||
Assert.Equal(5, await store.GetOplogDepthAsync(default));
|
||||
// And the next tick is clean: depth is not over cap any more.
|
||||
Assert.False(await store.EnforceCapsAsync(default));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task OplogDepth_AfterAgePrune_MatchesCount()
|
||||
{
|
||||
using var db = await NewOrdersDb();
|
||||
await WriteRows(db, 6);
|
||||
// Backdate the oldest three past the age cap; HLCs rise with seq, so this is a prefix.
|
||||
var expired = DateTimeOffset.UtcNow.AddDays(-30).ToUnixTimeMilliseconds() << 16;
|
||||
await db.ExecuteAsync(
|
||||
"UPDATE __localdb_oplog SET hlc = @h WHERE seq IN (SELECT seq FROM __localdb_oplog ORDER BY seq LIMIT 3)",
|
||||
new { h = expired });
|
||||
var store = new OplogStore(db, new ReplicationOptions());
|
||||
|
||||
Assert.True(await store.EnforceCapsAsync(default));
|
||||
|
||||
await AssertDepthMatchesCount(db, store);
|
||||
Assert.Equal(3, await store.GetOplogDepthAsync(default));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task OplogDepth_PartialAck_MatchesCount()
|
||||
{
|
||||
using var db = await NewOrdersDb();
|
||||
await WriteRows(db, 9);
|
||||
var store = new OplogStore(db, new ReplicationOptions());
|
||||
var batch = await store.ReadBatchAboveAsync(0, 100, default);
|
||||
|
||||
await store.RecordPeerAckAsync(batch[3].Seq, default);
|
||||
|
||||
await AssertDepthMatchesCount(db, store);
|
||||
Assert.Equal(5, await store.GetOplogDepthAsync(default));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task OplogDepth_AckPruneThenMoreWrites_MatchesCount()
|
||||
{
|
||||
using var db = await NewOrdersDb();
|
||||
await WriteRows(db, 4);
|
||||
var store = new OplogStore(db, new ReplicationOptions());
|
||||
await store.RecordPeerAckAsync(await store.GetMaxSeqAsync(default), default);
|
||||
|
||||
// The steady state of a converged pair: oplog pruned empty, watermark high, new writes above it.
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (91,'S',1),(92,'S',2)");
|
||||
|
||||
await AssertDepthMatchesCount(db, store);
|
||||
Assert.Equal(2, await store.GetOplogDepthAsync(default));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task OplogDepth_LargeBacklog_IsConstantTime()
|
||||
{
|
||||
// 200k rows: a COUNT(*) over the backlog runs ~200k VM steps per call (measured: 100,020 at
|
||||
// 50k rows), the seek-based formula runs 58 regardless of size. The loop below costs tens of
|
||||
// milliseconds at seek shape and seconds at scan shape, so the budget separates them by a
|
||||
// wide margin in both directions.
|
||||
using var db = await NewOrdersDb();
|
||||
await db.ExecuteAsync(
|
||||
"INSERT INTO __localdb_oplog (table_name, pk_json, row_json, hlc, node_id, is_tombstone) " +
|
||||
"WITH RECURSIVE c(x) AS (SELECT 1 UNION ALL SELECT x + 1 FROM c WHERE x < 200000) " +
|
||||
"SELECT 'orders', '{\"id\":' || x || '}', '{\"id\":' || x || '}', x << 16, 'n', 0 FROM c");
|
||||
var store = new OplogStore(db, new ReplicationOptions());
|
||||
|
||||
Assert.Equal(200_000, await store.GetOplogDepthAsync(default));
|
||||
|
||||
using var conn = db.CreateConnection();
|
||||
using var cmd = conn.CreateCommand();
|
||||
cmd.CommandText = OplogStore.DepthSql;
|
||||
var sw = System.Diagnostics.Stopwatch.StartNew();
|
||||
for (var i = 0; i < 2_000; i++)
|
||||
Assert.Equal(200_000L, (long)cmd.ExecuteScalar()!);
|
||||
sw.Stop();
|
||||
|
||||
Assert.True(sw.ElapsedMilliseconds < 1_500,
|
||||
$"2000 depth reads over a 200k backlog took {sw.ElapsedMilliseconds} ms — that is scan-shaped, not seek-shaped.");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PeerState_RoundTrips()
|
||||
{
|
||||
|
||||
@@ -128,4 +128,302 @@ public sealed class RegistrationTests : IDisposable
|
||||
Assert.Equal(new[] { "id" }, table.PkColumns);
|
||||
Assert.Equal(new[] { "id", "sku", "qty" }, table.Columns.Select(c => c.Name).ToArray());
|
||||
}
|
||||
|
||||
// ---- Deregistration ------------------------------------------------------------------
|
||||
|
||||
[Fact]
|
||||
public async Task Deregister_DropsTriggers_PrunesOplogAndLedger_LeavesDataAlone()
|
||||
{
|
||||
using var db = Create();
|
||||
await CreateOrders(db);
|
||||
db.RegisterReplicated("orders");
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (1,'A',1),(2,'B',2)");
|
||||
|
||||
var removed = db.DeregisterReplicated("orders");
|
||||
|
||||
Assert.True(removed);
|
||||
Assert.Empty(await Triggers(db));
|
||||
Assert.Equal(0, await CountAsync(db, "SELECT COUNT(*) FROM __localdb_oplog WHERE table_name='orders'"));
|
||||
Assert.Equal(0, await CountAsync(db, "SELECT COUNT(*) FROM __localdb_row_version WHERE table_name='orders'"));
|
||||
Assert.False(db.ReplicatedTables.ContainsKey("orders"));
|
||||
|
||||
// The consumer's own data is never touched — this removes CAPTURE, not rows.
|
||||
Assert.Equal(2, await CountAsync(db, "SELECT COUNT(*) FROM orders"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Deregister_StopsCapture()
|
||||
{
|
||||
using var db = Create();
|
||||
await CreateOrders(db);
|
||||
db.RegisterReplicated("orders");
|
||||
db.DeregisterReplicated("orders");
|
||||
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (1,'A',1)");
|
||||
await db.ExecuteAsync("UPDATE orders SET qty = 9 WHERE id = 1");
|
||||
await db.ExecuteAsync("DELETE FROM orders WHERE id = 1");
|
||||
|
||||
Assert.Equal(0, await CountAsync(db, "SELECT COUNT(*) FROM __localdb_oplog"));
|
||||
Assert.Equal(0, await CountAsync(db, "SELECT COUNT(*) FROM __localdb_row_version"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Deregister_IsIdempotent_SecondCallReportsNothingToDo()
|
||||
{
|
||||
using var db = Create();
|
||||
await CreateOrders(db);
|
||||
db.RegisterReplicated("orders");
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (1,'A',1)");
|
||||
|
||||
Assert.True(db.DeregisterReplicated("orders"));
|
||||
Assert.False(db.DeregisterReplicated("orders"));
|
||||
Assert.False(db.DeregisterReplicated("orders"));
|
||||
Assert.Empty(await Triggers(db));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Deregister_NeverRegisteredTable_IsANoOp()
|
||||
{
|
||||
using var db = Create();
|
||||
await CreateOrders(db);
|
||||
|
||||
Assert.False(db.DeregisterReplicated("orders"));
|
||||
Assert.False(db.DeregisterReplicated("ghost"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Deregister_ClearsTriggersLeftByAnEarlierProcess()
|
||||
{
|
||||
// The primary use: a database file registered by an OLDER build, opened by one that has
|
||||
// decided this node does not replicate. Nothing in memory says the table was ever
|
||||
// registered — the evidence is entirely on disk.
|
||||
using (var first = Create())
|
||||
{
|
||||
await CreateOrders(first);
|
||||
first.RegisterReplicated("orders");
|
||||
await first.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (1,'A',1)");
|
||||
}
|
||||
SqliteConnection.ClearAllPools();
|
||||
|
||||
using var second = Create();
|
||||
Assert.Equal(3, (await Triggers(second)).Count);
|
||||
Assert.False(second.ReplicatedTables.ContainsKey("orders"));
|
||||
|
||||
Assert.True(second.DeregisterReplicated("orders"));
|
||||
|
||||
Assert.Empty(await Triggers(second));
|
||||
Assert.Equal(0, await CountAsync(second, "SELECT COUNT(*) FROM __localdb_oplog"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Deregister_LeavesOtherTablesCapturing()
|
||||
{
|
||||
using var db = Create();
|
||||
await CreateOrders(db);
|
||||
await db.ExecuteAsync("CREATE TABLE widgets (id INTEGER PRIMARY KEY, name TEXT)");
|
||||
db.RegisterReplicated("orders");
|
||||
db.RegisterReplicated("widgets");
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (1,'A',1)");
|
||||
await db.ExecuteAsync("INSERT INTO widgets (id, name) VALUES (1,'W')");
|
||||
|
||||
db.DeregisterReplicated("orders");
|
||||
await db.ExecuteAsync("INSERT INTO widgets (id, name) VALUES (2,'W2')");
|
||||
|
||||
Assert.Equal(0, await CountAsync(db, "SELECT COUNT(*) FROM __localdb_oplog WHERE table_name='orders'"));
|
||||
Assert.Equal(2, await CountAsync(db, "SELECT COUNT(*) FROM __localdb_oplog WHERE table_name='widgets'"));
|
||||
Assert.True(db.ReplicatedTables.ContainsKey("widgets"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Deregister_ThenRegisterWithBaseline_RestoresTheLedger()
|
||||
{
|
||||
// Pruning the ledger is only safe because re-registration can re-baseline; this is that
|
||||
// round trip.
|
||||
using var db = Create();
|
||||
await CreateOrders(db);
|
||||
db.RegisterReplicated("orders");
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (1,'A',1),(2,'B',2)");
|
||||
|
||||
db.DeregisterReplicated("orders");
|
||||
Assert.Equal(0, await CountAsync(db, "SELECT COUNT(*) FROM __localdb_row_version"));
|
||||
|
||||
db.RegisterReplicated("orders", baselineExistingRows: true);
|
||||
|
||||
Assert.Equal(2, await CountAsync(db, "SELECT COUNT(*) FROM __localdb_row_version WHERE table_name='orders'"));
|
||||
}
|
||||
|
||||
// ---- Baselining ----------------------------------------------------------------------
|
||||
|
||||
[Fact]
|
||||
public async Task Register_WithoutBaseline_LeavesPreexistingRowsUnledgered()
|
||||
{
|
||||
// The documented CDC contract, unchanged: opting in is what changes behaviour, not upgrading.
|
||||
using var db = Create();
|
||||
await CreateOrders(db);
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (1,'A',1)");
|
||||
|
||||
db.RegisterReplicated("orders");
|
||||
|
||||
Assert.Equal(0, await CountAsync(db, "SELECT COUNT(*) FROM __localdb_row_version"));
|
||||
Assert.False(await NeedsSnapshot(db));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Register_WithBaseline_SeedsAtHlcZero_AndFlagsSnapshot()
|
||||
{
|
||||
using var db = Create();
|
||||
await CreateOrders(db);
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (1,'A',1),(2,'B',2)");
|
||||
|
||||
db.RegisterReplicated("orders", baselineExistingRows: true);
|
||||
|
||||
var seeded = await db.QueryAsync(
|
||||
"SELECT pk_json, hlc, node_id, is_tombstone FROM __localdb_row_version ORDER BY pk_json",
|
||||
r => (Pk: r.GetString(0), Hlc: r.GetInt64(1), Node: r.GetString(2), Tomb: r.GetInt64(3)));
|
||||
|
||||
Assert.Equal(2, seeded.Count);
|
||||
Assert.Equal(["{\"id\":1}", "{\"id\":2}"], seeded.Select(s => s.Pk));
|
||||
// HLC 0 is the floor: below every genuine stamp (physical ms << 16), so it can never beat one.
|
||||
Assert.All(seeded, s => Assert.Equal(0, s.Hlc));
|
||||
Assert.All(seeded, s => Assert.Equal(db.NodeId, s.Node));
|
||||
Assert.All(seeded, s => Assert.Equal(0, s.Tomb));
|
||||
|
||||
// Without the flag the seeding would be inert: no gap exists at the handshake, so the peer
|
||||
// would be told it needs no snapshot and the baselined rows would never travel.
|
||||
Assert.True(await NeedsSnapshot(db));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Register_WithBaseline_IsIdempotent_AndDoesNotReflagSnapshot()
|
||||
{
|
||||
using var db = Create();
|
||||
await CreateOrders(db);
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (1,'A',1)");
|
||||
|
||||
db.RegisterReplicated("orders", baselineExistingRows: true);
|
||||
await db.ExecuteAsync("UPDATE __localdb_peer_state SET needs_snapshot = 0 WHERE id = 1");
|
||||
|
||||
db.RegisterReplicated("orders", baselineExistingRows: true);
|
||||
|
||||
Assert.Equal(1, await CountAsync(db, "SELECT COUNT(*) FROM __localdb_row_version"));
|
||||
// Nothing new was seeded, so no resync is owed: passing true every boot is free after the first.
|
||||
Assert.False(await NeedsSnapshot(db));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Register_WithBaseline_NeverOverwritesACapturedVersion()
|
||||
{
|
||||
// The LWW-safety core: a row with a real, captured version must keep it. A floor that
|
||||
// clobbered genuine versions would make every baselined node look newer than its peer.
|
||||
using var db = Create();
|
||||
await CreateOrders(db);
|
||||
db.RegisterReplicated("orders");
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (1,'A',1)");
|
||||
var captured = (await db.QueryAsync(
|
||||
"SELECT hlc FROM __localdb_row_version WHERE pk_json='{\"id\":1}'", r => r.GetInt64(0)))[0];
|
||||
Assert.True(captured > 0);
|
||||
|
||||
// A second, pre-existing row that capture never saw (inserted with triggers removed).
|
||||
db.DeregisterReplicated("orders");
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (2,'B',2)");
|
||||
await db.ExecuteAsync(
|
||||
"INSERT INTO __localdb_row_version (table_name, pk_json, hlc, node_id, is_tombstone) " +
|
||||
"VALUES ('orders', '{\"id\":1}', @h, 'genuine', 0)", new { h = captured });
|
||||
|
||||
db.RegisterReplicated("orders", baselineExistingRows: true);
|
||||
|
||||
var versions = await db.QueryAsync(
|
||||
"SELECT pk_json, hlc, node_id FROM __localdb_row_version ORDER BY pk_json",
|
||||
r => (Pk: r.GetString(0), Hlc: r.GetInt64(1), Node: r.GetString(2)));
|
||||
Assert.Equal(2, versions.Count);
|
||||
Assert.Equal(captured, versions[0].Hlc);
|
||||
Assert.Equal("genuine", versions[0].Node);
|
||||
Assert.Equal(0, versions[1].Hlc);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Register_WithBaseline_SeedsPkJsonIdenticalToWhatCaptureWrites()
|
||||
{
|
||||
// A seeded key that differs by so much as a space from the capture triggers' json_object
|
||||
// output would be a DIFFERENT ledger row, and the baseline would silently never merge.
|
||||
using var db = Create();
|
||||
await db.ExecuteAsync("CREATE TABLE kv (a INTEGER, b TEXT, v TEXT, PRIMARY KEY (a, b))");
|
||||
await db.ExecuteAsync("INSERT INTO kv (a, b, v) VALUES (1, 'x', 'seeded')");
|
||||
|
||||
db.RegisterReplicated("kv", baselineExistingRows: true);
|
||||
await db.ExecuteAsync("UPDATE kv SET v = 'captured' WHERE a = 1 AND b = 'x'");
|
||||
|
||||
// One ledger row, not two: the capture upsert landed on the seeded key.
|
||||
var rows = await db.QueryAsync(
|
||||
"SELECT pk_json, hlc FROM __localdb_row_version", r => (Pk: r.GetString(0), Hlc: r.GetInt64(1)));
|
||||
Assert.Single(rows);
|
||||
Assert.Equal("{\"a\":1,\"b\":\"x\"}", rows[0].Pk);
|
||||
Assert.True(rows[0].Hlc > 0, "the genuine capture must have replaced the floor");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Register_WithBaseline_FloorLosesToEveryGenuineRemoteWrite()
|
||||
{
|
||||
// Proved through the real LWW path rather than by reasoning about the comparison: an
|
||||
// absurdly small remote HLC of 1 still beats the baseline floor of 0.
|
||||
using var db = Create();
|
||||
await CreateOrders(db);
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (1,'BASELINE',1)");
|
||||
db.RegisterReplicated("orders", baselineExistingRows: true);
|
||||
|
||||
var result = await new Replication.Internal.LwwApplier(db).ApplyBatchAsync(
|
||||
[new Replication.Internal.OplogEntryRecord(
|
||||
1, "orders", "{\"id\":1}", "{\"id\":1,\"sku\":\"REMOTE\",\"qty\":9}", 1, "peer", false)],
|
||||
default);
|
||||
|
||||
Assert.Equal(1, result.Applied);
|
||||
var sku = await db.QueryAsync("SELECT sku FROM orders WHERE id = 1", r => r.GetString(0));
|
||||
Assert.Equal("REMOTE", sku[0]);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Register_WithBaseline_TieBetweenTwoBaselinedNodes_ResolvesByNodeIdOrdinal()
|
||||
{
|
||||
// Two nodes that baselined the same key both hold HLC 0 — genuinely unordered history. The
|
||||
// node-id tie-break is what keeps that convergent instead of oscillating.
|
||||
using var db = Create();
|
||||
await CreateOrders(db);
|
||||
await db.ExecuteAsync("INSERT INTO orders (id, sku, qty) VALUES (1,'MINE',1)");
|
||||
db.RegisterReplicated("orders", baselineExistingRows: true);
|
||||
|
||||
var applier = new Replication.Internal.LwwApplier(db);
|
||||
var lower = await applier.ApplyBatchAsync(
|
||||
[new Replication.Internal.OplogEntryRecord(
|
||||
1, "orders", "{\"id\":1}", "{\"id\":1,\"sku\":\"LOWER\",\"qty\":9}", 0, "!" + db.NodeId, false)],
|
||||
default);
|
||||
Assert.Equal(1, lower.Discarded);
|
||||
|
||||
var higher = await applier.ApplyBatchAsync(
|
||||
[new Replication.Internal.OplogEntryRecord(
|
||||
2, "orders", "{\"id\":1}", "{\"id\":1,\"sku\":\"HIGHER\",\"qty\":9}", 0, db.NodeId + "z", false)],
|
||||
default);
|
||||
Assert.Equal(1, higher.Applied);
|
||||
|
||||
var sku = await db.QueryAsync("SELECT sku FROM orders WHERE id = 1", r => r.GetString(0));
|
||||
Assert.Equal("HIGHER", sku[0]);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Register_WithBaseline_EmptyTable_SeedsNothing_FlagsNothing()
|
||||
{
|
||||
using var db = Create();
|
||||
await CreateOrders(db);
|
||||
|
||||
db.RegisterReplicated("orders", baselineExistingRows: true);
|
||||
|
||||
Assert.Equal(0, await CountAsync(db, "SELECT COUNT(*) FROM __localdb_row_version"));
|
||||
Assert.False(await NeedsSnapshot(db));
|
||||
}
|
||||
|
||||
private static async Task<long> CountAsync(SqliteLocalDb db, string sql) =>
|
||||
(await db.QueryAsync(sql, r => r.GetInt64(0)))[0];
|
||||
|
||||
private static async Task<bool> NeedsSnapshot(SqliteLocalDb db) =>
|
||||
(await db.QueryAsync(
|
||||
"SELECT needs_snapshot FROM __localdb_peer_state WHERE id = 1", r => r.GetInt64(0)))[0] != 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user