aedb 0.3.1

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

use crate::error::{AedbError, ResourceType};
use crate::query::error::{QueryError, QueryErrorClass, QueryErrorCode};

#[test]
fn query_error_display_is_human_readable() {
    let err = QueryError::ColumnNotFound {
        table: "users".into(),
        column: "name".into(),
    };
    assert_eq!(err.to_string(), "column 'name' not found in table 'users'");
}

#[test]
fn maps_aedb_table_not_found_to_structured_query_error() {
    let err = QueryError::from(AedbError::NotFound {
        resource_type: ResourceType::Table,
        resource_id: "arcana.app.leaderboard_points".into(),
    });
    assert_eq!(
        err,
        QueryError::TableNotFound {
            project_id: "arcana".into(),
            table: "leaderboard_points".into(),
        }
    );
    assert!(err.is_table_not_found());
    assert_eq!(err.code(), QueryErrorCode::TableNotFound);
    assert_eq!(err.code_str(), "table_not_found");
    assert_eq!(err.class(), QueryErrorClass::Validation);
}

#[test]
fn query_error_code_strings_are_stable() {
    let expected = [
        (QueryErrorCode::TableNotFound, "table_not_found"),
        (QueryErrorCode::ColumnNotFound, "column_not_found"),
        (QueryErrorCode::TypeMismatch, "type_mismatch"),
        (QueryErrorCode::ScanBoundExceeded, "scan_bound_exceeded"),
        (QueryErrorCode::InvalidQuery, "invalid_query"),
        (QueryErrorCode::PermissionDenied, "permission_denied"),
        (QueryErrorCode::SeqNotYetVisible, "seq_not_yet_visible"),
        (QueryErrorCode::SeqGarbageCollected, "seq_garbage_collected"),
        (QueryErrorCode::CursorExpired, "cursor_expired"),
        (QueryErrorCode::InvalidCursor, "invalid_cursor"),
        (QueryErrorCode::SnapshotExpired, "snapshot_expired"),
        (
            QueryErrorCode::SnapshotLimitReached,
            "snapshot_limit_reached",
        ),
        (QueryErrorCode::InternalError, "internal_error"),
    ];
    for (code, stable) in expected {
        assert_eq!(code.as_str(), stable);
    }
}

#[test]
fn query_error_code_classes_describe_caller_behavior() {
    assert_eq!(
        QueryErrorCode::SnapshotExpired.class(),
        QueryErrorClass::Retryable
    );
    assert_eq!(
        QueryErrorCode::PermissionDenied.class(),
        QueryErrorClass::Permission
    );
    assert_eq!(
        QueryErrorCode::ScanBoundExceeded.class(),
        QueryErrorClass::Unavailable
    );
    assert_eq!(
        QueryErrorCode::InternalError.class(),
        QueryErrorClass::Integrity
    );
    assert!(QueryErrorCode::CursorExpired.is_retryable());
}