gluesql-shared-memory-storage 0.16.2

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
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

#![deny(clippy::str_to_string)]

mod alter_table;
mod index;
mod transaction;

use {
    async_trait::async_trait,
    futures::stream,
    gluesql_core::{
        data::{Key, Schema},
        error::Result,
        store::{DataRow, Metadata, RowIter, Store, StoreMut},
    },
    gluesql_memory_storage::MemoryStorage,
    std::sync::Arc,
    tokio::sync::RwLock,
};

#[derive(Clone, Debug)]
pub struct SharedMemoryStorage {
    pub database: Arc<RwLock<MemoryStorage>>,
}

impl SharedMemoryStorage {
    pub fn new() -> Self {
        let database = MemoryStorage::default();
        let database = Arc::new(RwLock::new(database));

        Self { database }
    }
}

impl Default for SharedMemoryStorage {
    fn default() -> Self {
        Self::new()
    }
}

impl From<MemoryStorage> for SharedMemoryStorage {
    fn from(storage: MemoryStorage) -> Self {
        let database = Arc::new(RwLock::new(storage));
        Self { database }
    }
}

#[async_trait(?Send)]
impl Store for SharedMemoryStorage {
    async fn fetch_all_schemas(&self) -> Result<Vec<Schema>> {
        let database = Arc::clone(&self.database);
        let database = database.read().await;

        database.fetch_all_schemas().await
    }
    async fn fetch_schema(&self, table_name: &str) -> Result<Option<Schema>> {
        let database = Arc::clone(&self.database);
        let database = database.read().await;

        database.fetch_schema(table_name).await
    }

    async fn fetch_data(&self, table_name: &str, key: &Key) -> Result<Option<DataRow>> {
        let database = Arc::clone(&self.database);
        let database = database.read().await;

        database.fetch_data(table_name, key).await
    }

    async fn scan_data(&self, table_name: &str) -> Result<RowIter> {
        let rows = self
            .database
            .read()
            .await
            .scan_data(table_name)
            .into_iter()
            .map(Ok);

        Ok(Box::pin(stream::iter(rows)))
    }
}

#[async_trait(?Send)]
impl StoreMut for SharedMemoryStorage {
    async fn insert_schema(&mut self, schema: &Schema) -> Result<()> {
        let database = Arc::clone(&self.database);
        let mut database = database.write().await;

        database.insert_schema(schema).await
    }

    async fn delete_schema(&mut self, table_name: &str) -> Result<()> {
        let database = Arc::clone(&self.database);
        let mut database = database.write().await;

        database.delete_schema(table_name).await
    }

    async fn append_data(&mut self, table_name: &str, rows: Vec<DataRow>) -> Result<()> {
        let database = Arc::clone(&self.database);
        let mut database = database.write().await;

        database.append_data(table_name, rows).await
    }

    async fn insert_data(&mut self, table_name: &str, rows: Vec<(Key, DataRow)>) -> Result<()> {
        let database = Arc::clone(&self.database);
        let mut database = database.write().await;

        database.insert_data(table_name, rows).await
    }

    async fn delete_data(&mut self, table_name: &str, keys: Vec<Key>) -> Result<()> {
        let database = Arc::clone(&self.database);
        let mut database = database.write().await;

        database.delete_data(table_name, keys).await
    }
}

impl Metadata for SharedMemoryStorage {}
impl gluesql_core::store::CustomFunction for SharedMemoryStorage {}
impl gluesql_core::store::CustomFunctionMut for SharedMemoryStorage {}