uqa-storage-sqlite 0.4.9

SQLite catalog, indexes, compressed storage, graph and key/value providers
Documentation
//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Latest payload joins preserve analytic results with less deterministic VM work.

use super::*;
use std::sync::{
    atomic::{AtomicUsize, Ordering},
    Arc,
};

const PREDECESSOR: &str = "SELECT h.key, CASE WHEN h.sequence <= ?3 AND h.compacted = 1 THEN NULL
     ELSE (SELECT value FROM _uqa_mvcc_versions WHERE key = h.key
     AND sequence <= ?3 ORDER BY sequence DESC LIMIT 1) END
     FROM _uqa_mvcc_heads h WHERE h.key >= ?1 AND (?2 IS NULL) ORDER BY h.key";

#[test]
fn latest_payload_join_matches_predecessors_with_less_sqlite_work() {
    let connection = Connection::open_in_memory().unwrap();
    connection.execute_batch(
        "CREATE TABLE _uqa_mvcc_heads(key BLOB PRIMARY KEY, sequence BLOB, compacted INTEGER) WITHOUT ROWID;
         CREATE TABLE _uqa_mvcc_versions(key BLOB, sequence BLOB, value BLOB, PRIMARY KEY(key,sequence)) WITHOUT ROWID"
    ).unwrap();
    let sequence = 1_u64.to_be_bytes();
    let mut expected = Vec::new();
    for id in 0_u64..1024 {
        let key = id.to_be_bytes();
        let value = (id % 7 != 0).then(|| (id + 1).to_be_bytes().to_vec());
        connection
            .execute(
                "INSERT INTO _uqa_mvcc_heads VALUES(?1,?2,0)",
                params![key.as_slice(), sequence.as_slice()],
            )
            .unwrap();
        connection
            .execute(
                "INSERT INTO _uqa_mvcc_versions VALUES(?1,?2,?3)",
                params![key.as_slice(), sequence.as_slice(), value.as_deref()],
            )
            .unwrap();
        expected.push((key.to_vec(), value));
    }
    let steps = Arc::new(AtomicUsize::new(0));
    let counter = Arc::clone(&steps);
    connection
        .progress_handler(
            1,
            Some(move || {
                counter.fetch_add(1, Ordering::Relaxed);
                false
            }),
        )
        .unwrap();
    let mut measured = Vec::new();
    for sql in [PREDECESSOR, payload_statement(false, false)] {
        steps.store(0, Ordering::Relaxed);
        let mut statement = connection.prepare(sql).unwrap();
        let found = statement
            .query_map(
                params![b"".as_slice(), None::<&[u8]>, sequence.as_slice()],
                |row| Ok((row.get::<_, Vec<u8>>(0)?, row.get::<_, Option<Vec<u8>>>(1)?)),
            )
            .unwrap()
            .collect::<Result<Vec<_>, _>>()
            .unwrap();
        assert_eq!(found, expected);
        measured.push(steps.load(Ordering::Relaxed));
    }
    assert!(
        measured[1] < measured[0],
        "join={}, predecessor={}",
        measured[1],
        measured[0]
    );
}