# SQLite Steady-State Query Execution Database Candidate

SQLite is a CPU-only embedded relational database. This release traces **only
the steady-state query execution phase**: a process that opens an
already-populated database read-only and does nothing but execute prepared
queries against it in a loop.

- Official source: https://www.sqlite.org/
- SQLite version: 3.53.4, amalgamation
  `sqlite-amalgamation-3530400.zip` from https://www.sqlite.org/2026/
- Source id: `2026-07-24 19:02:57 bf7c7f30031888f4e796e429ab3978879485813aaca6f641c7b33e4e09459bcc`
- `sqlite3.c` sha256: `b1dd5d74ec7f29055a6684fa06fb3c2f6821c87dd38f9a458dfd2e8a1db28189`
- `sqlite3.h` sha256: `919e7f2e8ed1d8f56ac17b412b8971c76aa5d1a879752cc6058f75e7d5910e1d`
- Build: `gcc -O2 -g -no-pie -DSQLITE_THREADSAFE=0 -DSQLITE_OMIT_LOAD_EXTENSION
  -DSQLITE_DEFAULT_MEMSTATUS=0 -DSQLITE_MAX_MMAP_SIZE=4294967296`
  (see `workload/src/build.sh`)
- Database: 3,000,000 rows, `records(id INTEGER PRIMARY KEY, k INTEGER, v0, v1,
  payload TEXT(64))` plus secondary index `idx_k(k)`; 4 KiB pages, 302 MB file
- Connection: single thread, `SQLITE_OPEN_READONLY`, `PRAGMA query_only=ON`,
  `PRAGMA locking_mode=EXCLUSIVE`, `PRAGMA mmap_size=2 GiB`,
  `PRAGMA cache_size=-524288`

## Phase separation

The workload is split into two *separate binaries* so that no excluded-phase
code path is even reachable from the traced process:

| binary | phase | traced |
|---|---|---|
| `sqlite_setup` | database file allocation, `CREATE TABLE`, `CREATE INDEX`, schema initialization, bulk `INSERT` of 3,000,000 rows, `ANALYZE` | **no** |
| `sqlite_query` | steady-state query execution against the existing database | **yes** |

`sqlite_query` contains no DDL and no DML. Its only non-query work is
`sqlite3_open_v2()` plus four `sqlite3_prepare_v2()` calls, which together
account for **480,604 instructions** measured on a query-free run — less than
1% of one 60,000,000-instruction fingerprint segment, and 0.014% of the
3,383,340,000-instruction traced run. The first released SimPoint region begins
660,000,000 instructions into the run, so no released archive contains any of
it.

## Query mix

The steady-state loop runs 3 rounds of 4 query phases, all read-only and all
issued from statements prepared once and reset per iteration:

| phase | query | exercises |
|---|---|---|
| 1 | `SELECT v0,v1,payload FROM records WHERE id = ?` (60,000x/round) | rowid B-tree descent, record lookup |
| 2 | `SELECT id,v0 FROM records INDEXED BY idx_k WHERE k = ?` (50,000x/round) | index B-tree descent + rowid table seek, key comparison |
| 3 | `SELECT id,v0,v1 FROM records WHERE id BETWEEN ? AND ?` (4,900x/round, 64 rows) | cursor movement across leaf pages, cell parsing |
| 4 | `SELECT id,k FROM records INDEXED BY idx_k WHERE k BETWEEN ? AND ?` (5,000x/round) | covering-index cursor movement, record compare |

Total traced run: 3,383,340,000 fetched instructions in 57 fingerprint segments
of 60,000,000 instructions. Both the fingerprint pass and the four trace
captures execute the identical command line, and the workload is deterministic
(fixed LCG seeds, read-only database), so segment indices map to the same
instructions in both.

## SimPoint selection

BBV clustering (SimPoint 3.2, `-maxK 5 -dim 100 -coveragePct .99`) chose k = 4.
The clusters recovered exactly the four query phases and their three
repetitions:

| cluster | segments | query phase | representative |
|---|---|---|---|
| 2 | 0-4, 19-22, 38-41 | rowid point lookups | 22 |
| 3 | 5-8, 23-27, 42-46 | index lookups | 27 |
| 1 | 9-13, 28-32, 47-51 | rowid range scans | 12 |
| 0 | 14-18, 33-37, 52-56 | index range scans | 54 |

SimPoint's own representative for cluster 0 was segment 56, the partial trailing
segment (16,512,018 instructions). It was replaced by segment 54, the
next-closest full segment to the cluster centroid (distance 0.0371956 vs
0.0366442); see `simpoints/substitutions.txt`. Every representative's preceding
segment belongs to the same cluster, so each archive's warmup chunk is in the
same query phase as its measured chunk.

## Released archives

Each archive holds `chunk.0000` (60,000,000-instruction warmup) plus
`chunk.0001` (the 60,000,000-instruction SimPoint region), i.e.
**120,000,000 fetched instructions**, confirmed by
`drcachesim -simulator_type basic_counts` (`validation/basic_counts/`). All four
pass `unzip -t`, have distinct sha256 values, and contain a single thread with
zero system-call markers.

## Steady-state evidence

`validation/steady_state/` attributes 100% of the instructions in each released
archive to functions of the traced binary. Query execution accounts for
85.2-96.3% of every window; the remainder is SQLite support code (memory
management, `sqlite3VdbeMemRelease`, etc.) and libc. Zero instructions fall in
any database-creation, schema-initialization, dataset-population or
SQL-compilation function (`excluded_phase_check.tsv`).