Run pgbench's transaction on a bank of 100,000 accounts, beside SQLite (090)

benchmarks/bank/bank.aup keeps accounts, tellers and branches as keyed
lists and a history list; a transfer changes a row of each and appends a
history row in one event, as pgbench's TPC-B-like transaction does in
SQL. run.py makes a scale's rows and drives transfers through the load
generator's new transfer kind; sqlite-bank.c runs the same tables and
SQL on SQLite 3.46.1, a connection a thread, WAL.

With lists as trees, transfers run at 30.5k a second on 1,000 accounts
and 24.5k on 100,000 (RAM store, one connection thread, HTTP and JSON
included), where they ran at 3.2k on 30,000 before. Durable on the SD
card, Pure makes 1,339 a second and SQLite with synchronous=FULL 84 to
153. SQLite in process with no HTTP makes about 40k in RAM: recorded as
it is, with the write amplification of 100,000-row tables on the card
and ad hoc queries as what comes next.

1 files changed, 64 insertions, 0 deletions

diff --git a/benchmarks/bank/bank.aup b/benchmarks/bank/bank.aup
new file mode 100644
index 0000000..acc7938
--- /dev/null
+++ b/benchmarks/bank/bank.aup
@@ -0,0 +1,64 @@
+# A bank as pgbench's TPC-B-like transaction: accounts, tellers and branches,
+# each a list kept in key order, and a history of every transfer. A transfer
+# moves a teller's delta into an account, the teller and its branch, and
+# records it, all in one event: one transaction over four tables.
+record Account {
+  aid = 0
+  bid = 0
+  balance = 0
+  filler: text
+}
+record Teller {
+  tid = 0
+  bid = 0
+  balance = 0
+}
+record Branch {
+  bid = 0
+  balance = 0
+}
+record Transfer {
+  tid = 0
+  bid = 0
+  aid = 0
+  delta = 0
+  at = 0
+}
+
+state accounts: list of Account by aid
+state tellers: list of Teller by tid
+state branches: list of Branch by bid
+state history: list of Transfer
+
+input branch = message {
+  bid: u32
+}
+input teller = message {
+  tid: u32
+  bid: u32
+}
+input account = message {
+  aid: u32
+  bid: u32
+}
+input transfer = message {
+  aid: u32
+  tid: u32
+  bid: u32
+  delta: number
+}
+
+on branch { branches.add(Branch { bid: branch.bid }) }
+on teller { tellers.add(Teller { tid: teller.tid, bid: teller.bid }) }
+on account { accounts.add(Account { aid: account.aid, bid: account.bid, filler: "" }) }
+
+on transfer {
+  accounts[transfer.aid].balance = accounts[transfer.aid].balance + transfer.delta
+  tellers[transfer.tid].balance = tellers[transfer.tid].balance + transfer.delta
+  branches[transfer.bid].balance = branches[transfer.bid].balance + transfer.delta
+  history.append(Transfer { tid: transfer.tid, bid: transfer.bid, aid: transfer.aid, delta: transfer.delta, at: now })
+}
+
+view accounts_count = accounts.count
+view history_count = history.count
+view total = sum(b.balance for b in branches)