uqa-storage-sqlite 0.5.4

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

//! Physical statement reuse preserves fresh parameters and transactional results.

use super::*;
use rusqlite::hooks::{AuthAction, AuthContext, Authorization};
use std::sync::{
    atomic::{AtomicUsize, Ordering},
    Arc,
};

#[test]
fn unchanged_btree_projection_keeps_its_equality_keys_without_writes() {
    let connection = Connection::open_in_memory().unwrap();
    connection.execute_batch("CREATE TABLE _btree_index_entries (table_name TEXT NOT NULL, field TEXT NOT NULL, doc_id INTEGER NOT NULL, value_json TEXT NOT NULL, PRIMARY KEY(table_name,field,doc_id)) WITHOUT ROWID").unwrap();
    crate::btree_index::equality::install(&connection).unwrap();
    let layout = super::super::NativeRecordFamily::BtreeIndexEntries.layout();
    let control = StorageReadControl::with_limit(65536);
    let original = br#"{"type":"Float","value":0}"#;
    let values = |id, encoded| {
        [
            ValueRef::Text(b"items"),
            ValueRef::Text(b"key"),
            ValueRef::Integer(id),
            ValueRef::Text(encoded),
        ]
    };
    for id in 1..=32 {
        upsert(&connection, layout, &values(id, original), &control).unwrap();
    }
    let before = connection.total_changes();
    for _ in 0..2 {
        for id in 1..=32 {
            upsert(&connection, layout, &values(id, original), &control).unwrap();
        }
    }
    assert_eq!(
        connection.total_changes() - before,
        0,
        "unchanged index entries must not rewrite rows or rebuild equality keys"
    );
    assert_eq!(
        connection
            .query_row(
                "SELECT count(*) FROM _btree_equality_keys WHERE equality_key IS NOT NULL",
                [],
                |row| row.get::<_, i64>(0)
            )
            .unwrap(),
        32
    );
    let key: Vec<u8> = connection
        .query_row(
            "SELECT equality_key FROM _btree_equality_keys WHERE doc_id=1",
            [],
            |row| row.get(0),
        )
        .unwrap();
    let transaction = connection.unchecked_transaction().unwrap();
    // SQL-equal values can have different stored representations: the negative zero must replace positive zero even though its lookup key is the same.
    let negative_zero = br#"{"type":"Float","value":9223372036854775808}"#;
    let before = transaction.total_changes();
    upsert(&transaction, layout, &values(1, negative_zero), &control).unwrap();
    assert!(transaction.total_changes() > before);
    let (encoded, new_key): (String, Vec<u8>) = transaction.query_row("SELECT value_json,equality_key FROM _btree_index_entries JOIN _btree_equality_keys USING(table_name,field,doc_id) WHERE doc_id=1",[],|row|Ok((row.get(0)?,row.get(1)?))).unwrap();
    assert_eq!(encoded.as_bytes(), negative_zero);
    assert_eq!(new_key, key);
    transaction.rollback().unwrap();
    let encoded: String = connection
        .query_row(
            "SELECT value_json FROM _btree_index_entries WHERE doc_id=1",
            [],
            |row| row.get(0),
        )
        .unwrap();
    assert_eq!(encoded.as_bytes(), original);
    assert_eq!(control.memory().used(), 0);
}

#[test]
fn physical_row_operations_reuse_preparation_with_fresh_bindings() {
    let connection = Connection::open_in_memory().unwrap();
    connection
        .execute_batch("CREATE TABLE _metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL)")
        .unwrap();
    let compiled = Arc::new(AtomicUsize::new(0));
    let counter = Arc::clone(&compiled);
    connection
        .authorizer(Some(move |context: AuthContext<'_>| {
            if matches!(
                context.action,
                AuthAction::Select | AuthAction::Insert { .. } | AuthAction::Delete { .. }
            ) {
                counter.fetch_add(1, Ordering::Relaxed);
            }
            Authorization::Allow
        }))
        .unwrap();
    let control = StorageReadControl::with_limit(65536);
    let layout = super::super::NativeRecordFamily::Metadata.layout();
    let transaction = connection.unchecked_transaction().unwrap();
    for number in 0..128 {
        let key = format!("key:{number:04}\0%_");
        let text = format!("value:{number}");
        let values = [
            ValueRef::Text(key.as_bytes()),
            ValueRef::Text(text.as_bytes()),
        ];
        upsert(&transaction, layout, &values, &control).unwrap();
        let encoded_key = physical_key(layout, &values, &control).unwrap();
        let found = get(&transaction, layout, &encoded_key, &control)
            .unwrap()
            .unwrap();
        assert_eq!(&*decode_row(&found, 2, &control).unwrap(), &values);
        remove(&transaction, layout, &encoded_key, &control).unwrap();
        assert!(get(&transaction, layout, &encoded_key, &control)
            .unwrap()
            .is_none());
        upsert(&transaction, layout, &values, &control).unwrap();
    }
    assert!(
        compiled.load(Ordering::Relaxed) <= 8,
        "fixed row operations must not compile statements per row"
    );
    transaction.rollback().unwrap();
    assert_eq!(
        connection
            .query_row("SELECT count(*) FROM _metadata", [], |row| row
                .get::<_, i64>(0))
            .unwrap(),
        0
    );
    assert_eq!(control.memory().used(), 0);
    connection
        .authorizer(None::<fn(AuthContext<'_>) -> Authorization>)
        .unwrap();
}

#[test]
fn a_row_is_read_with_its_size_until_it_exceeds_the_inline_limit() {
    let connection = Connection::open_in_memory().unwrap();
    connection
        .execute_batch("CREATE TABLE _metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL)")
        .unwrap();
    let layout = super::super::NativeRecordFamily::Metadata.layout();
    let control = StorageReadControl::with_limit(4 << 20);
    // The key and the value of the second row total exactly the inline limit; the third is one byte over it.
    let rows = [
        ("a", String::new()),
        ("b", "v".repeat(INLINE_ROW_BYTES - 1)),
        ("c", "v".repeat(INLINE_ROW_BYTES)),
        ("d", "v".repeat(300_000)),
    ];
    let mut keys = Vec::new();
    for (key, value) in &rows {
        let values = [
            ValueRef::Text(key.as_bytes()),
            ValueRef::Text(value.as_bytes()),
        ];
        upsert(&connection, layout, &values, &control).unwrap();
        keys.push(physical_key(layout, &values, &control).unwrap());
    }
    for ((key, value), encoded) in rows.iter().zip(&keys) {
        let found = get(&connection, layout, encoded, &control)
            .unwrap()
            .unwrap();
        assert_eq!(
            &*decode_row(&found, 2, &control).unwrap(),
            &[
                ValueRef::Text(key.as_bytes()),
                ValueRef::Text(value.as_bytes())
            ]
        );
    }
    let mut visited = Vec::new();
    visit(&connection, layout, &control, |values| {
        visited.push(values[1].as_str().unwrap().len());
        Ok(())
    })
    .unwrap();
    assert_eq!(
        visited,
        [0, INLINE_ROW_BYTES - 1, INLINE_ROW_BYTES, 300_000]
    );
    drop(keys);
    assert_eq!(control.memory().used(), 0);

    // A row over the inline limit is read only after three times its size is reserved; the rows under it still fit.
    let narrow = StorageReadControl::with_limit(64 * 1024);
    let encoded = |key: &str| {
        physical_key(
            layout,
            &[ValueRef::Text(key.as_bytes()), ValueRef::Text(b"")],
            &narrow,
        )
        .unwrap()
    };
    assert!(get(&connection, layout, &encoded("c"), &narrow)
        .unwrap()
        .is_some());
    assert!(matches!(
        get(&connection, layout, &encoded("d"), &narrow),
        Err(crate::mvcc::Error::Version(VersionError::Memory(_)))
    ));
    assert!(get(&connection, layout, &encoded("missing"), &narrow)
        .unwrap()
        .is_none());
    assert_eq!(narrow.memory().used(), 0);
}

#[test]
fn binary_rows_reserve_binary_bytes_and_preserve_text_conversion() {
    for encoding in ["UTF-8", "UTF-16le", "UTF-16be"] {
        let connection = Connection::open_in_memory().unwrap();
        connection
            .execute_batch(&format!(
                "PRAGMA encoding = '{encoding}'; CREATE TABLE _schemas (name TEXT PRIMARY KEY, role_owner TEXT NOT NULL, acl_json TEXT)"
            ))
            .unwrap();
        let layout = super::super::NativeRecordFamily::Schemas.layout();
        let control = StorageReadControl::with_limit(40 * 1024);
        let binary = vec![0xa7; 16 * 1024];
        let text = "가\0é🌲".repeat(128);
        for owner in [ValueRef::Blob(&binary), ValueRef::Text(text.as_bytes())] {
            let values = [
                ValueRef::Text(b"namespace"),
                owner,
                ValueRef::Text(text.as_bytes()),
            ];
            upsert(&connection, layout, &values, &control).unwrap();
            let key = physical_key(layout, &values, &control).unwrap();
            let row = get(&connection, layout, &key, &control).unwrap().unwrap();
            assert_eq!(&*decode_row(&row, 3, &control).unwrap(), &values);
            drop(row);
            let mut count = 0;
            visit(&connection, layout, &control, |found| {
                assert_eq!(found, values);
                count += 1;
                Ok(())
            })
            .unwrap();
            assert_eq!(count, 1);
            let narrow = StorageReadControl::with_limit(1024);
            assert!(matches!(
                get(&connection, layout, &key, &narrow),
                Err(crate::mvcc::Error::Version(VersionError::Memory(_)))
            ));
            assert_eq!(narrow.memory().used(), 0);
        }
        assert_eq!(control.memory().used(), 0);
    }
}