fsqlite 0.1.18

Public API facade
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

//! bd-5310l follow-on: is execute_body (~biggest phase, the residual gap vs C SQLite) dominated by
//! the SEEK/cursor-open (systemic MVCC/btree — no clean lever) or by ROW-PROCESSING (Column reads +
//! Row materialization — potentially reducible)? A point-lookup HIT vs MISS split answers it: MISS =
//! cursor open + seek(not found); HIT = the same + Column x2 + ResultRow + materialize. HIT-MISS
//! isolates the row-processing. Runs in `fsqlite` (no criterion dev-dep) so it builds light/reliable.
//!
//! Run: RCH_REQUIRE_REMOTE=1 env -u CARGO_TARGET_DIR rch exec -- \
//!   cargo test --profile release-perf -p fsqlite --test execute_body_split -- --ignored --nocapture

#![allow(clippy::cast_precision_loss)]

use std::time::Instant;

use fsqlite::Connection;
use fsqlite_core::connection::{
    hot_path_profile_snapshot, reset_hot_path_profile, set_hot_path_profile_enabled,
};

fn measure(conn: &Connection, sql: &str, n: u64) -> (f64, f64) {
    for _ in 0..200 {
        let _ = conn.query(sql).unwrap();
    }
    set_hot_path_profile_enabled(true);
    reset_hot_path_profile();
    let t = Instant::now();
    for _ in 0..n {
        let _ = conn.query(sql).unwrap();
    }
    let wall = t.elapsed().as_nanos() as f64 / n as f64;
    let snap = hot_path_profile_snapshot();
    reset_hot_path_profile();
    set_hot_path_profile_enabled(false);
    (wall, snap.execute_body_time_ns as f64 / n as f64)
}

#[test]
#[ignore = "profile; run under --profile release-perf"]
fn execute_body_hit_vs_miss() {
    let conn = Connection::open(":memory:").expect("open");
    conn.execute("CREATE TABLE t (id INTEGER PRIMARY KEY, v TEXT, k INTEGER);")
        .unwrap();
    conn.execute("CREATE INDEX idx_t_k ON t(k);").unwrap();
    for i in 1..=5000_i64 {
        conn.execute(&format!(
            "INSERT INTO t VALUES ({i}, 'row{i}', {});",
            i % 100
        ))
        .unwrap();
    }
    // Tiny 1-row table: a MISS here does cursor-open + a ~1-level seek, isolating the fixed
    // cursor-open cost from the per-level B-tree descent that the 5000-row MISS pays.
    conn.execute("CREATE TABLE s (id INTEGER PRIMARY KEY, v TEXT);")
        .unwrap();
    conn.execute("INSERT INTO s VALUES (1, 'only');").unwrap();
    let n = 200_000u64;
    let cases = [
        ("SELECT 1 (no cursor)", "SELECT 1"),
        (
            "MISS tiny table (1 row)",
            "SELECT id, v FROM s WHERE id = 9999999",
        ),
        (
            "point MISS (5000 rows)",
            "SELECT id, v FROM t WHERE id = 9999999",
        ),
        (
            "point HIT (id present)",
            "SELECT id, v FROM t WHERE id = 2500",
        ),
        ("point HIT covering id", "SELECT id FROM t WHERE id = 2500"),
    ];
    eprintln!("\n########## bd-5310l execute_body HIT vs MISS split ##########");
    for (label, sql) in cases {
        let (wall, exec) = measure(&conn, sql, n);
        eprintln!("  [{label:24}] wall = {wall:8.1} ns   execute_body = {exec:8.1} ns");
    }
    eprintln!(
        "  -> (HIT execute_body) - (MISS execute_body) = the Column-read + Row-materialize cost;\n     \
         if ~0, the ~14us is seek/cursor-open (systemic MVCC/btree, no clean lever)."
    );
    eprintln!("########## end execute_body split ##########\n");
}