aedb 0.2.8

Embedded Rust storage engine with transactional commits, WAL durability, and snapshot-consistent reads
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use super::tests::setup;
use super::{
    CapturingQueryExecutionRequest, ReadSetCollector, execute_query_with_options_capturing,
};
use crate::catalog::types::Value;
use crate::commit::tx::{ReadKey, ReadRange};
use crate::query::plan::{Expr, Query, QueryOptions};

#[test]
fn read_set_captures_primary_key_point_lookup() {
    let (keyspace, catalog) = setup();
    let snapshot = keyspace.snapshot();

    let mut collector = ReadSetCollector::new();
    let result = execute_query_with_options_capturing(CapturingQueryExecutionRequest {
        snapshot: &snapshot,
        catalog: &catalog,
        project_id: "A",
        scope_id: "app",
        query: Query::select(&["id", "name"])
            .from("users")
            .where_(Expr::Eq("id".into(), Value::Integer(7))),
        options: &QueryOptions {
            allow_full_scan: true,
            ..QueryOptions::default()
        },
        snapshot_seq: 0,
        max_scan_rows: usize::MAX,
        read_set: Some(&mut collector),
    })
    .expect("query");
    assert_eq!(result.rows.len(), 1);

    let read_set = collector.into_inner();
    assert_eq!(read_set.points.len(), 1, "expected one point entry");
    assert!(read_set.ranges.is_empty(), "no ranges for PK lookup");
    let entry = &read_set.points[0];
    let ReadKey::TableRow {
        project_id,
        scope_id,
        table_name,
        primary_key,
    } = &entry.key
    else {
        panic!("expected TableRow read key");
    };
    assert_eq!(project_id, "A");
    assert_eq!(scope_id, "app");
    assert_eq!(table_name, "users");
    assert_eq!(primary_key, &vec![Value::Integer(7)]);
}

#[test]
fn read_set_captures_indexed_range_as_touched_pks() {
    let (keyspace, catalog) = setup();
    let snapshot = keyspace.snapshot();

    let mut collector = ReadSetCollector::new();
    let result = execute_query_with_options_capturing(CapturingQueryExecutionRequest {
        snapshot: &snapshot,
        catalog: &catalog,
        project_id: "A",
        scope_id: "app",
        query: Query::select(&["id", "age"])
            .from("users")
            .where_(Expr::Gte("age".into(), Value::Integer(60)))
            .limit(10),
        options: &QueryOptions {
            allow_full_scan: true,
            ..QueryOptions::default()
        },
        snapshot_seq: 0,
        max_scan_rows: usize::MAX,
        read_set: Some(&mut collector),
    })
    .expect("query");
    assert!(!result.rows.is_empty());

    let read_set = collector.into_inner();
    assert!(
        !read_set.points.is_empty(),
        "indexed range scan should capture touched pks as points"
    );
    assert!(read_set.ranges.is_empty(), "no coarse range expected");
}

#[test]
fn read_set_captures_full_table_scan_as_range() {
    let (keyspace, catalog) = setup();
    let snapshot = keyspace.snapshot();

    let mut collector = ReadSetCollector::new();
    let _ = execute_query_with_options_capturing(CapturingQueryExecutionRequest {
        snapshot: &snapshot,
        catalog: &catalog,
        project_id: "A",
        scope_id: "app",
        query: Query::select(&["*"]).from("users"),
        options: &QueryOptions {
            allow_full_scan: true,
            ..QueryOptions::default()
        },
        snapshot_seq: 0,
        max_scan_rows: usize::MAX,
        read_set: Some(&mut collector),
    })
    .expect("query");

    let read_set = collector.into_inner();
    assert_eq!(
        read_set.ranges.len(),
        1,
        "full scan should record one coarse range"
    );
    let ReadRange::TableRange { table_name, .. } = &read_set.ranges[0].range else {
        panic!("expected TableRange");
    };
    assert_eq!(table_name, "users");
}