linkrs_storage/engine/graph_storage/
writer_api.rs

1use linkrs_core::types::{InsertEdgeInfo, InsertVertexInfo, UpdateInfo, VertexId};
2use linkrs_core::{Edge, EdgeDeleteKey, StorageError, Vertex};
3
4use crate::StorageWriter;
5
6use super::writer;
7use super::GraphStorage;
8
9impl StorageWriter for GraphStorage {
10    fn insert_vertex(&mut self, space: &str, vertex: Vertex) -> Result<VertexId, StorageError> {
11        self.ctx.check_write_admission()?;
12        let result = writer::insert_vertex(&self.ctx, space, vertex)?;
13        self.commit_auto_if_needed()?;
14        Ok(result)
15    }
16
17    fn update_vertex(&mut self, space: &str, vertex: Vertex) -> Result<(), StorageError> {
18        self.ctx.check_write_admission()?;
19        writer::update_vertex(&self.ctx, space, vertex)?;
20        self.commit_auto_if_needed()
21    }
22
23    fn update_vertex_replace(&mut self, space: &str, vertex: Vertex) -> Result<(), StorageError> {
24        self.ctx.check_write_admission()?;
25        writer::update_vertex_replace(&self.ctx, space, vertex)?;
26        self.commit_auto_if_needed()
27    }
28
29    fn delete_vertex(&mut self, space: &str, tag: &str, id: &VertexId) -> Result<(), StorageError> {
30        self.ctx.check_write_admission()?;
31        writer::delete_vertex(&self.ctx, space, tag, id)?;
32        self.commit_auto_if_needed()
33    }
34
35    fn delete_vertex_with_edges(
36        &mut self,
37        space: &str,
38        tag: &str,
39        id: &VertexId,
40    ) -> Result<(), StorageError> {
41        self.ctx.check_write_admission()?;
42        writer::delete_vertex_with_edges(&self.ctx, space, tag, id)?;
43        self.commit_auto_if_needed()
44    }
45
46    fn batch_delete_vertices_with_edges(
47        &mut self,
48        space: &str,
49        tag: &str,
50        ids: &[VertexId],
51    ) -> Result<usize, StorageError> {
52        self.ctx.check_write_admission()?;
53        let result = writer::batch_delete_vertices_with_edges(&self.ctx, space, tag, ids)?;
54        self.commit_auto_if_needed()?;
55        Ok(result)
56    }
57
58    fn batch_insert_vertices(
59        &mut self,
60        space: &str,
61        vertices: Vec<Vertex>,
62    ) -> Result<Vec<VertexId>, StorageError> {
63        self.ctx.check_write_admission()?;
64        let result = writer::batch_insert_vertices(&self.ctx, space, vertices)?;
65        self.commit_auto_if_needed()?;
66        Ok(result)
67    }
68
69    fn batch_insert_vertices_with_split(
70        &mut self,
71        space: &str,
72        vertices: Vec<Vertex>,
73        auto_split: bool,
74    ) -> Result<Vec<VertexId>, StorageError> {
75        self.ctx.check_write_admission()?;
76        let result =
77            writer::batch_insert_vertices_with_split(&self.ctx, space, vertices, auto_split)?;
78        self.commit_auto_if_needed()?;
79        Ok(result)
80    }
81
82    fn insert_edge(&mut self, space: &str, edge: Edge) -> Result<(), StorageError> {
83        self.ctx.check_write_admission()?;
84        writer::insert_edge(&self.ctx, space, edge)?;
85        self.commit_auto_if_needed()
86    }
87
88    fn update_edge(&mut self, space: &str, edge: Edge) -> Result<(), StorageError> {
89        self.ctx.check_write_admission()?;
90        writer::update_edge(&self.ctx, space, edge)?;
91        self.commit_auto_if_needed()
92    }
93
94    fn update_edge_replace(&mut self, space: &str, edge: Edge) -> Result<(), StorageError> {
95        self.ctx.check_write_admission()?;
96        writer::update_edge_replace(&self.ctx, space, edge)?;
97        self.commit_auto_if_needed()
98    }
99
100    fn delete_edge(
101        &mut self,
102        space: &str,
103        src: &VertexId,
104        dst: &VertexId,
105        edge_type: &str,
106        rank: i64,
107    ) -> Result<(), StorageError> {
108        self.ctx.check_write_admission()?;
109        writer::delete_edge(&self.ctx, space, src, dst, edge_type, rank)?;
110        self.commit_auto_if_needed()
111    }
112
113    fn batch_insert_edges(&mut self, space: &str, edges: Vec<Edge>) -> Result<(), StorageError> {
114        self.ctx.check_write_admission()?;
115        writer::batch_insert_edges(&self.ctx, space, edges)?;
116        self.commit_auto_if_needed()
117    }
118
119    fn batch_delete_edges(
120        &mut self,
121        space: &str,
122        deletes: &[EdgeDeleteKey],
123    ) -> Result<usize, StorageError> {
124        self.ctx.check_write_admission()?;
125        let result = writer::batch_delete_edges(&self.ctx, space, deletes)?;
126        self.commit_auto_if_needed()?;
127        Ok(result)
128    }
129
130    fn insert_vertex_data(
131        &mut self,
132        space: &str,
133        info: &InsertVertexInfo,
134    ) -> Result<bool, StorageError> {
135        self.ctx.check_write_admission()?;
136        let result = writer::insert_vertex_data(&self.ctx, space, info)?;
137        self.commit_auto_if_needed()?;
138        Ok(result)
139    }
140
141    fn insert_edge_data(
142        &mut self,
143        space: &str,
144        info: &InsertEdgeInfo,
145    ) -> Result<bool, StorageError> {
146        self.ctx.check_write_admission()?;
147        let result = writer::insert_edge_data(&self.ctx, space, info)?;
148        self.commit_auto_if_needed()?;
149        Ok(result)
150    }
151
152    fn delete_vertex_data(
153        &mut self,
154        space: &str,
155        tag: &str,
156        vertex_id: &str,
157    ) -> Result<bool, StorageError> {
158        self.ctx.check_write_admission()?;
159        let result = writer::delete_vertex_data(&self.ctx, space, tag, vertex_id)?;
160        self.commit_auto_if_needed()?;
161        Ok(result)
162    }
163
164    fn delete_edge_data(
165        &mut self,
166        space: &str,
167        src: &str,
168        dst: &str,
169        rank: i64,
170    ) -> Result<bool, StorageError> {
171        self.ctx.check_write_admission()?;
172        let result = writer::delete_edge_data(&self.ctx, space, src, dst, rank)?;
173        self.commit_auto_if_needed()?;
174        Ok(result)
175    }
176
177    fn update_data(
178        &mut self,
179        space: &str,
180        space_id: u64,
181        info: &UpdateInfo,
182    ) -> Result<bool, StorageError> {
183        self.ctx.check_write_admission()?;
184        let result = writer::update_data(&self.ctx, space, space_id, info)?;
185        self.commit_auto_if_needed()?;
186        Ok(result)
187    }
188}
linkrs_storage/engine/graph_storage/writer_api.rs

linkrs_storage/engine/graph_storage/
writer_api.rs
