kglite 0.10.1

Pure-Rust knowledge graph engine — Cypher pipeline, snapshot/working CoW transactions, columnar/mmap/disk storage backends, optional dataset loaders (SEC EDGAR, Sodir, Wikidata). PyO3 wrappers live in the sibling kglite-py crate (the Python wheel); embeddable directly from any Rust binary without PyO3 in the dep tree.
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

//! Demonstrates the snapshot/working CoW transaction model from
//! `kglite::api::session` — including OCC conflict handling.
//!
//! Two transactions race to mutate the same graph: A wins, B's
//! commit detects the conflict and is rejected. This is the
//! pattern bindings (Bolt server, etc.) use to surface
//! "Transaction conflict — retry the transaction" errors.
//!
//! Run with:
//!
//! ```bash
//! cargo run -p kglite --example embedded_session
//! ```

use kglite::api::session::{CommitOutcome, ExecuteOptions, Session};
use kglite::api::DirGraph;
use std::collections::HashMap;
use std::sync::Arc;

fn opts<'a>(params: &'a HashMap<String, kglite::api::Value>) -> ExecuteOptions<'a> {
    ExecuteOptions {
        params,
        deadline: None,
        max_rows: None,
        lazy_eligible: false,
        disabled_passes: None,
        embedder: None,
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let session = Arc::new(Session::new(DirGraph::new()));
    let params: HashMap<String, kglite::api::Value> = HashMap::new();

    // ── Tx A: begin, create a node ────────────────────────────────
    let mut tx_a = session.begin();
    let working_a = tx_a.working_mut()?;
    kglite::api::session::execute_mut(
        working_a,
        "CREATE (:Person {id: 1, name: 'Alice'})",
        &opts(&params),
    )?;
    println!("Tx A: created Person(id=1, name='Alice') in working copy");

    // ── Tx B: begin (sees pre-A snapshot), create a different node ─
    let mut tx_b = session.begin();
    let working_b = tx_b.working_mut()?;
    kglite::api::session::execute_mut(
        working_b,
        "CREATE (:Person {id: 2, name: 'Bob'})",
        &opts(&params),
    )?;
    println!("Tx B: created Person(id=2, name='Bob') in working copy");

    // ── Commit A: succeeds, graph version bumps to 1 ──────────────
    let outcome_a = session.commit(tx_a, /* check_occ = */ true);
    match outcome_a {
        CommitOutcome::Committed { new_version } => {
            println!("\n✓ Tx A committed → version {}", new_version);
        }
        other => panic!("expected Committed, got {:?}", other),
    }

    // ── Commit B: OCC detects stale snapshot (base 0, current 1) ──
    let outcome_b = session.commit(tx_b, /* check_occ = */ true);
    match outcome_b {
        CommitOutcome::ConflictDetected {
            current_version,
            base_version,
        } => {
            println!(
                "✗ Tx B rejected (OCC): base_version={} but current_version={}",
                base_version, current_version
            );
            println!("  Client retry pattern: re-run the transaction against a fresh snapshot.");
        }
        other => panic!("expected ConflictDetected, got {:?}", other),
    }

    // ── Verify final state: only Alice landed ─────────────────────
    let snap = session.snapshot();
    let outcome = kglite::api::session::execute_read(
        &snap,
        "MATCH (p:Person) RETURN p.name AS name ORDER BY p.id",
        &opts(&params),
    )?;
    println!("\nFinal graph:");
    for row in &outcome.result.rows {
        if let Some(kglite::api::Value::String(s)) = row.first() {
            println!("  - {}", s);
        }
    }

    Ok(())
}