qualia_core_db/sparql_library/
sparql_update.rs1use crate::sparql_ast::*;
6use crate::NQuin;
7
8#[repr(C)]
10#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11pub enum UpdateOperation {
12 InsertData { quins: [NQuin; 64], quin_count: u8 },
14 DeleteData { quins: [NQuin; 64], quin_count: u8 },
16 DeleteInsert {
18 delete_pattern: PatternId,
19 insert_pattern: PatternId,
20 where_pattern: PatternId,
21 },
22 Load { uri: u64, graph: u64 },
24 Clear { graph: u64 },
26 Create { graph: u64 },
28 Drop { graph: u64 },
30}
31
32pub struct UpdateExecutor<'a> {
34 pub quins: &'a mut Vec<NQuin>,
35}
36
37impl<'a> UpdateExecutor<'a> {
38 pub fn new(quins: &'a mut Vec<NQuin>) -> Self {
40 Self { quins }
41 }
42
43 pub fn execute(
45 &mut self,
46 operation: &UpdateOperation,
47 ctx: &SparqlQueryContext,
48 ) -> Result<u64, String> {
49 match operation {
50 UpdateOperation::InsertData { quins, quin_count } => {
51 self.execute_insert_data(quins, *quin_count)
52 }
53 UpdateOperation::DeleteData { quins, quin_count } => {
54 self.execute_delete_data(quins, *quin_count)
55 }
56 UpdateOperation::DeleteInsert {
57 delete_pattern,
58 insert_pattern,
59 where_pattern,
60 } => self.execute_delete_insert(*delete_pattern, *insert_pattern, *where_pattern, ctx),
61 UpdateOperation::Load { uri, graph } => self.execute_load(*uri, *graph),
62 UpdateOperation::Clear { graph } => self.execute_clear(*graph),
63 UpdateOperation::Create { graph } => self.execute_create(*graph),
64 UpdateOperation::Drop { graph } => self.execute_drop(*graph),
65 }
66 }
67
68 fn execute_insert_data(&mut self, quins: &[NQuin], quin_count: u8) -> Result<u64, String> {
69 let count = quin_count as usize;
70 if count > quins.len() {
71 return Err("Quin count exceeds array length".to_string());
72 }
73
74 for i in 0..count {
75 self.quins.push(quins[i]);
76 }
77
78 Ok(count as u64)
79 }
80
81 fn execute_delete_data(&mut self, quins: &[NQuin], quin_count: u8) -> Result<u64, String> {
82 let count = quin_count as usize;
83 if count > quins.len() {
84 return Err("Quin count exceeds array length".to_string());
85 }
86
87 let mut deleted = 0;
88 for i in 0..count {
89 let target = quins[i];
90 self.quins.retain(|quin| {
92 quin.subject != target.subject
93 || quin.predicate != target.predicate
94 || quin.object != target.object
95 });
96 deleted += 1;
97 }
98
99 Ok(deleted)
100 }
101
102 fn execute_delete_insert(
103 &mut self,
104 delete_pattern: PatternId,
105 insert_pattern: PatternId,
106 where_pattern: PatternId,
107 ctx: &SparqlQueryContext,
108 ) -> Result<u64, String> {
109 let mut plan = crate::sparql_library::sparql_planner::ExecutionPlan::new();
111 let root_op = crate::sparql_library::sparql_planner::QueryPlanner::plan_pattern(
112 where_pattern,
113 ctx,
114 &mut plan,
115 )?;
116 plan.root_operator = root_op;
117
118 let bindings = {
120 let executor = crate::sparql_library::sparql_executor::QueryExecutor::new(&self.quins);
121 executor.execute(&plan, ctx)?
122 };
123
124 let mut deleted = 0;
125 let mut insert_quins = Vec::new();
126
127 let evaluate_pattern =
129 |pattern_id: PatternId, ctx: &SparqlQueryContext, row: &BindingRow| -> Option<NQuin> {
130 if let Some(pattern) = ctx.patterns.get(pattern_id as usize) {
131 match pattern {
132 Pattern::Triple {
133 subject,
134 predicate,
135 object,
136 } => {
137 let s = if *subject < 0x8000_0000_0000_0000 {
138 row.get(*subject as u8)?
139 } else {
140 *subject
141 };
142 let p = if *predicate < 0x8000_0000_0000_0000 {
143 row.get(*predicate as u8)?
144 } else {
145 *predicate
146 };
147 let o = if *object < 0x8000_0000_0000_0000 {
148 row.get(*object as u8)?
149 } else {
150 *object
151 };
152 Some(NQuin {
153 subject: s,
154 predicate: p,
155 object: o,
156 context: 0,
157 metadata: 0,
158 parity: 0,
159 })
160 }
161 _ => None,
162 }
163 } else {
164 None
165 }
166 };
167
168 for binding in bindings {
169 if let Some(target) = evaluate_pattern(delete_pattern, ctx, &binding) {
170 let initial_len = self.quins.len();
171 self.quins.retain(|q| {
172 q.subject != target.subject
173 || q.predicate != target.predicate
174 || q.object != target.object
175 });
176 deleted += initial_len - self.quins.len();
177 }
178 if let Some(new_quin) = evaluate_pattern(insert_pattern, ctx, &binding) {
179 insert_quins.push(new_quin);
180 }
181 }
182
183 self.quins.extend(insert_quins);
184 Ok(deleted as u64)
185 }
186
187 fn execute_load(&mut self, _uri: u64, _graph: u64) -> Result<u64, String> {
188 Ok(0)
197 }
198
199 fn execute_clear(&mut self, graph: u64) -> Result<u64, String> {
200 let original_len = self.quins.len();
202 self.quins.retain(|quin| quin.context != graph);
203 Ok((original_len - self.quins.len()) as u64)
204 }
205
206 fn execute_create(&mut self, _graph: u64) -> Result<u64, String> {
207 Ok(1)
215 }
216
217 fn execute_drop(&mut self, graph: u64) -> Result<u64, String> {
218 let original_len = self.quins.len();
220 self.quins.retain(|quin| quin.context != graph);
221
222 Ok((original_len - self.quins.len()) as u64)
224 }
225}
226
227#[repr(C)]
229#[derive(Debug, Clone, Copy)]
230pub struct UpdateQuery {
231 pub operation: UpdateOperation,
232}
233
234#[cfg(test)]
235mod tests {
236 use super::*;
237
238 #[test]
239 fn test_insert_data() {
240 let mut quins = vec![];
241 let mut executor = UpdateExecutor::new(&mut quins);
242
243 let test_quin = NQuin {
244 subject: 1,
245 predicate: 2,
246 object: 3,
247 context: 0,
248 metadata: 0,
249 parity: 0,
250 };
251
252 let mut quins_array = [NQuin::default(); 64];
253 quins_array[0] = test_quin;
254
255 let result = executor.execute_insert_data(&quins_array, 1).unwrap();
256 assert_eq!(result, 1);
257 assert_eq!(executor.quins.len(), 1);
258 }
259
260 #[test]
261 fn test_delete_data() {
262 let mut quins = vec![NQuin {
263 subject: 1,
264 predicate: 2,
265 object: 3,
266 context: 0,
267 metadata: 0,
268 parity: 0,
269 }];
270
271 let mut executor = UpdateExecutor::new(&mut quins);
272
273 let test_quin = NQuin {
274 subject: 1,
275 predicate: 2,
276 object: 3,
277 context: 0,
278 metadata: 0,
279 parity: 0,
280 };
281
282 let mut quins_array = [NQuin::default(); 64];
283 quins_array[0] = test_quin;
284
285 let result = executor.execute_delete_data(&quins_array, 1).unwrap();
286 assert_eq!(result, 1);
287 assert_eq!(executor.quins.len(), 0);
288 }
289}