llkv-runtime 0.3.0-alpha

Execution runtime for the LLKV toolkit.
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

use std::sync::Arc;

use arrow::datatypes::DataType;
use llkv_runtime::{
    AggregateExpr, InsertPlan, InsertSource, PlanValue, RuntimeContext, RuntimeStatementResult,
    TransactionKind, row,
};
use llkv_storage::pager::MemPager;

#[test]
fn fluent_create_insert_select() {
    let pager = Arc::new(MemPager::default());
    let context = Arc::new(RuntimeContext::new(pager));

    let create_result = context
        .create_table_builder("people")
        .with_column("id", DataType::Int64)
        .with_column("name", DataType::Utf8)
        .finish()
        .expect("create table");
    assert!(matches!(
        create_result,
        RuntimeStatementResult::CreateTable { .. }
    ));

    let table = context.table("people").expect("table handle");
    let insert_result = table
        .insert_rows([
            row().with("id", 1_i64).with("name", "alice"),
            row().with("id", 2_i64).with("name", "bob"),
        ])
        .expect("insert rows");
    assert!(matches!(
        insert_result,
        RuntimeStatementResult::Insert {
            rows_inserted: 2,
            ..
        }
    ));

    let rows = table
        .lazy()
        .expect("lazy scan")
        .select_columns(["id", "name"])
        .collect_rows_vec()
        .expect("collect rows");

    assert_eq!(rows.len(), 2);
    assert_eq!(
        rows,
        vec![
            vec![PlanValue::Integer(1), PlanValue::String("alice".into())],
            vec![PlanValue::Integer(2), PlanValue::String("bob".into())]
        ]
    );
}

#[test]
fn fluent_transaction_flow() {
    let pager = Arc::new(MemPager::default());
    let context = Arc::new(RuntimeContext::new(pager));
    let session = context.create_session();

    context
        .create_table_builder("numbers")
        .with_column("n", DataType::Int64)
        .finish()
        .expect("create table");

    let table = context.table("numbers").expect("table handle");

    session.begin_transaction().expect("begin tx");

    let insert_plan = InsertPlan {
        table: "numbers".into(),
        columns: vec![],
        source: InsertSource::Rows(vec![vec![PlanValue::Integer(41)]]),
    };
    let insert_result = session.insert(insert_plan).expect("insert");
    assert!(matches!(
        insert_result,
        RuntimeStatementResult::Insert {
            rows_inserted: 1,
            ..
        }
    ));

    let rows = session.table_rows("numbers").expect("session rows");
    assert_eq!(rows, vec![vec![PlanValue::Integer(41)]]);

    let commit = session.commit_transaction().expect("commit");
    assert!(matches!(
        commit,
        RuntimeStatementResult::Transaction {
            kind: TransactionKind::Commit
        }
    ));

    let persisted_rows = table
        .lazy()
        .expect("lazy scan")
        .select_columns(["n"])
        .collect_rows_vec()
        .expect("rows");
    assert_eq!(persisted_rows, vec![vec![PlanValue::Integer(41)]]);

    let aggregate_rows = table
        .lazy()
        .expect("lazy scan")
        .aggregate(vec![AggregateExpr::sum_int64("n", "sum")])
        .collect_rows_vec()
        .expect("aggregate rows");
    assert_eq!(aggregate_rows, vec![vec![PlanValue::Integer(41)]]);
}