gluesql 0.19.0

GlueSQL - Open source SQL database engine fully written in Rust with pure functional execution layer, easily swappable storage and web assembly support!
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

#![cfg(any(feature = "gluesql_memory_storage", feature = "gluesql_sled_storage"))]
use {
    futures::executor::block_on,
    gluesql::{
        FromGlueRow,
        core::store::{GStore, GStoreMut, Planner},
        prelude::*,
    },
};

async fn basic<T: GStore + GStoreMut + Planner>(mut glue: Glue<T>) {
    // Demonstrate FromGlueRow derive + Payload conversion to struct
    #[derive(Debug, PartialEq, FromGlueRow)]
    struct ApiRow {
        id: i64,
        name: String,
        is: bool,
    }

    assert_eq!(
        glue.execute("DROP TABLE IF EXISTS api_test").await,
        Ok(vec![Payload::DropTable(0)])
    );

    assert_eq!(
        glue.execute(
            "CREATE TABLE api_test (id INTEGER, name TEXT, nullable TEXT NULL, is BOOLEAN)"
        )
        .await,
        Ok(vec![Payload::Create])
    );

    assert_eq!(
        glue.execute(
            "
                INSERT INTO
                    api_test (id, name, nullable, is)
                VALUES
                    (1, 'test1', 'not null', TRUE),
                    (2, 'test2', NULL, FALSE)"
        )
        .await,
        Ok(vec![Payload::Insert(2)])
    );

    let rows: Vec<ApiRow> = glue
        .execute("SELECT id, name, is FROM api_test")
        .await
        .rows_as::<ApiRow>()
        .unwrap();
    assert_eq!(
        rows,
        vec![
            ApiRow {
                id: 1,
                name: "test1".into(),
                is: true
            },
            ApiRow {
                id: 2,
                name: "test2".into(),
                is: false
            },
        ]
    );
}

#[cfg(feature = "gluesql_sled_storage")]
#[test]
fn sled_basic() {
    use gluesql_sled_storage::{SledStorage, sled};

    let config = sled::Config::default()
        .path("data/using_config")
        .temporary(true);

    let storage = SledStorage::try_from(config).unwrap();
    let glue = Glue::new(storage);

    block_on(basic(glue));
}

#[cfg(feature = "gluesql_memory_storage")]
#[test]
fn memory_basic() {
    use gluesql_memory_storage::MemoryStorage;

    let storage = MemoryStorage::default();
    let glue = Glue::new(storage);

    block_on(basic(glue));
}