this repo has no description
1use async_trait::async_trait;
2use dashmap::DashMap;
3use std::sync::Arc;
4use crate::{
5 NodeId, RelationshipId, Node, Relationship, Result,
6 storage::StorageEngine,
7};
8
9pub struct MemoryStore {
10 data: Arc<DashMap<Vec<u8>, Vec<u8>>>,
11}
12
13impl MemoryStore {
14 pub fn new() -> Self {
15 Self {
16 data: Arc::new(DashMap::new()),
17 }
18 }
19}
20
21#[async_trait]
22impl StorageEngine for MemoryStore {
23 async fn put_node(&self, node: &Node) -> Result<()> {
24 let key = format!("node:{}", node.id.0).into_bytes();
25 let value = bincode::serialize(node)?;
26 self.data.insert(key, value);
27 Ok(())
28 }
29
30 async fn get_node(&self, id: NodeId) -> Result<Option<Node>> {
31 let key = format!("node:{}", id.0).into_bytes();
32 match self.data.get(&key) {
33 Some(value) => {
34 let node = bincode::deserialize(&value)?;
35 Ok(Some(node))
36 }
37 None => Ok(None),
38 }
39 }
40
41 async fn delete_node(&self, id: NodeId) -> Result<()> {
42 let key = format!("node:{}", id.0).into_bytes();
43 self.data.remove(&key);
44 Ok(())
45 }
46
47 async fn put_relationship(&self, rel: &Relationship) -> Result<()> {
48 let rel_key = format!("rel:{}", rel.id.0).into_bytes();
49 let rel_value = bincode::serialize(rel)?;
50 self.data.insert(rel_key, rel_value);
51
52 let start_key = format!("node_rels:{}", rel.start_node.0).into_bytes();
53 let mut start_rels = self.get_node_relationships(rel.start_node).await?;
54 if !start_rels.contains(&rel.id) {
55 start_rels.push(rel.id);
56 }
57 self.data.insert(start_key, bincode::serialize(&start_rels)?);
58
59 if rel.start_node != rel.end_node {
60 let end_key = format!("node_rels:{}", rel.end_node.0).into_bytes();
61 let mut end_rels = self.get_node_relationships(rel.end_node).await?;
62 if !end_rels.contains(&rel.id) {
63 end_rels.push(rel.id);
64 }
65 self.data.insert(end_key, bincode::serialize(&end_rels)?);
66 }
67
68 Ok(())
69 }
70
71 async fn get_relationship(&self, id: RelationshipId) -> Result<Option<Relationship>> {
72 let key = format!("rel:{}", id.0).into_bytes();
73 match self.data.get(&key) {
74 Some(value) => {
75 let rel = bincode::deserialize(&value)?;
76 Ok(Some(rel))
77 }
78 None => Ok(None),
79 }
80 }
81
82 async fn delete_relationship(&self, id: RelationshipId) -> Result<()> {
83 if let Some(rel) = self.get_relationship(id).await? {
84 let rel_key = format!("rel:{}", id.0).into_bytes();
85 self.data.remove(&rel_key);
86
87 let start_key = format!("node_rels:{}", rel.start_node.0).into_bytes();
88 let mut start_rels = self.get_node_relationships(rel.start_node).await?;
89 start_rels.retain(|&r| r != id);
90 self.data.insert(start_key, bincode::serialize(&start_rels)?);
91
92 if rel.start_node != rel.end_node {
93 let end_key = format!("node_rels:{}", rel.end_node.0).into_bytes();
94 let mut end_rels = self.get_node_relationships(rel.end_node).await?;
95 end_rels.retain(|&r| r != id);
96 self.data.insert(end_key, bincode::serialize(&end_rels)?);
97 }
98 }
99 Ok(())
100 }
101
102 async fn put_node_relationships(&self, node_id: NodeId, relationships: &[RelationshipId]) -> Result<()> {
103 let key = format!("node_rels:{}", node_id.0).into_bytes();
104 let value = bincode::serialize(relationships)?;
105 self.data.insert(key, value);
106 Ok(())
107 }
108
109 async fn get_node_relationships(&self, node_id: NodeId) -> Result<Vec<RelationshipId>> {
110 let key = format!("node_rels:{}", node_id.0).into_bytes();
111 match self.data.get(&key) {
112 Some(value) => {
113 let rels = bincode::deserialize(&value)?;
114 Ok(rels)
115 }
116 None => Ok(Vec::new()),
117 }
118 }
119
120 async fn put_raw(&self, key: &[u8], value: &[u8]) -> Result<()> {
121 self.data.insert(key.to_vec(), value.to_vec());
122 Ok(())
123 }
124
125 async fn get_raw(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
126 match self.data.get(key) {
127 Some(value) => Ok(Some(value.clone())),
128 None => Ok(None),
129 }
130 }
131
132 async fn delete_raw(&self, key: &[u8]) -> Result<()> {
133 self.data.remove(key);
134 Ok(())
135 }
136
137 async fn flush(&self) -> Result<()> {
138 Ok(())
139 }
140
141 async fn compact(&self) -> Result<()> {
142 Ok(())
143 }
144
145 async fn put_index_config(&self, _name: &str, _config_data: &[u8]) -> Result<()> {
146 // No-op for memory store - indexes are not persisted
147 Ok(())
148 }
149
150 async fn get_index_config(&self, _name: &str) -> Result<Option<Vec<u8>>> {
151 // No-op for memory store - indexes are not persisted
152 Ok(None)
153 }
154
155 async fn delete_index_config(&self, _name: &str) -> Result<()> {
156 // No-op for memory store - indexes are not persisted
157 Ok(())
158 }
159
160 async fn list_index_configs(&self) -> Result<Vec<String>> {
161 // No-op for memory store - indexes are not persisted
162 Ok(Vec::new())
163 }
164
165 async fn put_index_data(&self, _index_key: &str, _data: &[u8]) -> Result<()> {
166 // No-op for memory store - indexes are not persisted
167 Ok(())
168 }
169
170 async fn get_index_data(&self, _index_key: &str) -> Result<Option<Vec<u8>>> {
171 // No-op for memory store - indexes are not persisted
172 Ok(None)
173 }
174
175 async fn delete_index_data(&self, _index_key: &str) -> Result<()> {
176 // No-op for memory store - indexes are not persisted
177 Ok(())
178 }
179
180 async fn list_index_data_keys(&self, _prefix: &str) -> Result<Vec<String>> {
181 // No-op for memory store - indexes are not persisted
182 Ok(Vec::new())
183 }
184}