uqa-execution 0.4.0

Volcano physical operators with row-batch pipelines
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

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

use super::*;

#[cfg(not(target_os = "emscripten"))]
#[test]
fn private_index_values_and_rollback_journal_are_encrypted_without_database_credentials() {
    const SECRET: &str = "private-execution-index-secret-repeated-marker";
    let directory = tempfile::tempdir().unwrap();
    let path = directory.path().join("index.db");
    let connection = open(&path).unwrap();
    connection
        .execute_batch("CREATE TABLE values_for_test (value TEXT)")
        .unwrap();
    connection
        .execute("INSERT INTO values_for_test VALUES (?1)", [SECRET])
        .unwrap();
    connection
        .execute_batch("BEGIN; UPDATE values_for_test SET value = value || value")
        .unwrap();
    assert!(path.with_extension("db-journal").exists());
    for entry in std::fs::read_dir(directory.path()).unwrap() {
        let bytes = std::fs::read(entry.unwrap().path()).unwrap();
        assert!(!bytes
            .windows(SECRET.len())
            .any(|bytes| bytes == SECRET.as_bytes()));
    }
    connection.execute_batch("ROLLBACK").unwrap();
    assert_eq!(
        connection
            .query_row("SELECT value FROM values_for_test", [], |row| row
                .get::<_, String>(0))
            .unwrap(),
        SECRET
    );
    let plain = rusqlite::Connection::open(&path).unwrap();
    assert!(plain
        .execute_batch("SELECT * FROM values_for_test")
        .is_err());
    assert_eq!(
        connection
            .pragma_query_value(None, "temp_store", |row| row.get::<_, i64>(0))
            .unwrap(),
        2
    );
}

#[test]
fn failed_temporary_open_does_not_create_an_index_or_retain_its_directory() {
    let path = {
        let directory = tempfile::tempdir().unwrap();
        let path = directory.path().to_owned();
        let obstruction = path.join("not-a-directory");
        std::fs::write(&obstruction, b"unchanged").unwrap();
        assert!(open(&obstruction.join("index.db")).is_err());
        assert_eq!(std::fs::read(obstruction).unwrap(), b"unchanged");
        assert_eq!(std::fs::read_dir(&path).unwrap().count(), 1);
        path
    };
    assert!(!path.exists());
}