aedb 0.2.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
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

use aedb::AedbInstance;
use aedb::catalog::schema::IndexType;
use aedb::catalog::types::{ColumnType, Row, Value};
use aedb::commit::validation::Mutation;
use aedb::config::AedbConfig;
use aedb::declarative::TableMigrationBuilder;
use aedb::declarative::{AsyncIndexSpec, IndexSpec, MigrationSpec, SchemaMigrationPlan, TableSpec};
use aedb::query::plan::{Expr, Query};
use tempfile::tempdir;

#[test]
fn table_spec_builds_table_and_index_ddl() {
    let table = TableSpec::new("sessions")
        .column("id", ColumnType::Text, false)
        .column("user_id", ColumnType::Text, false)
        .column("expires_at", ColumnType::Timestamp, false)
        .primary_key(&["id"])
        .add_index(IndexSpec::new(
            "idx_sessions_user",
            &["user_id"],
            IndexType::BTree,
        ))
        .add_async_index(AsyncIndexSpec::new(
            "aidx_sessions_list",
            &["id", "user_id", "expires_at"],
        ));

    let ddl = table.to_ddl("p", "auth").expect("to ddl");
    assert_eq!(ddl.len(), 3);
}

#[tokio::test]
async fn declarative_migration_plan_runs_end_to_end() {
    let dir = tempdir().expect("tempdir");
    let db = AedbInstance::open(AedbConfig::default(), dir.path()).expect("open");

    let sessions = TableSpec::new("sessions")
        .column("id", ColumnType::Text, false)
        .column("user_id", ColumnType::Text, false)
        .column("expires_at", ColumnType::Timestamp, false)
        .column("revoked", ColumnType::Boolean, false)
        .primary_key(&["id"])
        .add_index(IndexSpec::new(
            "idx_sessions_user",
            &["user_id"],
            IndexType::BTree,
        ));

    let migration = MigrationSpec::new(1, "create sessions")
        .up_table("p", "auth", &sessions)
        .expect("up table")
        .down_drop_table("p", "auth", &sessions);

    let plan = SchemaMigrationPlan::new("p", "auth").add(migration);

    let report = plan.run(&db).await.expect("run plan");
    assert_eq!(report.applied.len(), 1);
    assert_eq!(report.current_version, 1);

    db.commit(Mutation::Upsert {
        project_id: "p".into(),
        scope_id: "auth".into(),
        table_name: "sessions".into(),
        primary_key: vec![Value::Text("s1".into())],
        row: Row::from_values(vec![
            Value::Text("s1".into()),
            Value::Text("u1".into()),
            Value::Timestamp(200),
            Value::Boolean(false),
        ]),
    })
    .await
    .expect("insert session");

    let q = Query::select(&["id"])
        .from("sessions")
        .where_(Expr::Eq("user_id".into(), Value::Text("u1".into())));
    let result = db.query("p", "auth", q).await.expect("query");
    assert_eq!(result.rows.len(), 1);
}

#[tokio::test]
async fn table_migration_builder_applies_and_rolls_back_schema_changes() {
    let dir = tempdir().expect("tempdir");
    let db = AedbInstance::open(AedbConfig::default(), dir.path()).expect("open");

    let sessions = TableSpec::new("sessions")
        .column("id", ColumnType::Text, false)
        .column("user_id", ColumnType::Text, false)
        .column("expires_at", ColumnType::Timestamp, false)
        .column("revoked", ColumnType::Boolean, false)
        .primary_key(&["id"])
        .add_index(IndexSpec::new(
            "idx_sessions_user",
            &["user_id"],
            IndexType::BTree,
        ));

    let create_schema = MigrationSpec::new(1, "create sessions")
        .up_table("p", "auth", &sessions)
        .expect("up table")
        .down_drop_table("p", "auth", &sessions);

    let alter_schema = TableMigrationBuilder::new(2, "alter sessions", "p", "auth", "sessions")
        .add_column(aedb::catalog::schema::ColumnDef {
            name: "device_id".into(),
            col_type: ColumnType::Text,
            nullable: true,
        })
        .rename_column("revoked", "is_revoked")
        .drop_index(
            "idx_sessions_user",
            IndexSpec::new("idx_sessions_user", &["user_id"], IndexType::BTree),
        )
        .add_index(IndexSpec::new(
            "idx_sessions_device",
            &["device_id"],
            IndexType::BTree,
        ))
        .build()
        .expect("build alter migration");

    let plan = SchemaMigrationPlan::new("p", "auth")
        .add(create_schema)
        .add(alter_schema);
    let migrations = plan.migrations().expect("migrations");

    db.run_migrations(migrations.clone())
        .await
        .expect("run migrations");

    let table = db
        .describe_table("p", "auth", "sessions")
        .await
        .expect("describe table");
    assert!(table.columns.iter().any(|c| c.name == "device_id"));
    assert!(table.columns.iter().any(|c| c.name == "is_revoked"));
    assert!(!table.columns.iter().any(|c| c.name == "revoked"));
    assert!(
        db.index_exists("p", "auth", "sessions", "idx_sessions_device")
            .await
            .expect("idx_sessions_device")
    );
    assert!(
        !db.index_exists("p", "auth", "sessions", "idx_sessions_user")
            .await
            .expect("idx_sessions_user")
    );

    db.rollback_to_migration("p", "auth", 1, migrations)
        .await
        .expect("rollback to version 1");

    let rolled_back = db
        .describe_table("p", "auth", "sessions")
        .await
        .expect("describe rolled back table");
    assert!(rolled_back.columns.iter().any(|c| c.name == "revoked"));
    assert!(!rolled_back.columns.iter().any(|c| c.name == "is_revoked"));
    assert!(
        db.index_exists("p", "auth", "sessions", "idx_sessions_user")
            .await
            .expect("idx_sessions_user after rollback")
    );
    assert!(
        !db.index_exists("p", "auth", "sessions", "idx_sessions_device")
            .await
            .expect("idx_sessions_device after rollback")
    );
}