Skip to main content

qualia_core_db/sparql_library/
sparql_update.rs

1//! SPARQL Update Operations
2//!
3//! Implements SPARQL 1.1 Update Language (INSERT DATA, DELETE DATA, DELETE/INSERT WHERE).
4
5use crate::sparql_ast::*;
6use crate::NQuin;
7
8/// Update operation types
9#[repr(C)]
10#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11pub enum UpdateOperation {
12    /// INSERT DATA { triples }
13    InsertData { quins: [NQuin; 64], quin_count: u8 },
14    /// DELETE DATA { triples }
15    DeleteData { quins: [NQuin; 64], quin_count: u8 },
16    /// DELETE { pattern } INSERT { pattern } WHERE { pattern }
17    DeleteInsert {
18        delete_pattern: PatternId,
19        insert_pattern: PatternId,
20        where_pattern: PatternId,
21    },
22    /// LOAD \<uri\> INTO GRAPH \<graph\>
23    Load { uri: u64, graph: u64 },
24    /// CLEAR GRAPH \<graph\>
25    Clear { graph: u64 },
26    /// CREATE GRAPH \<graph\>
27    Create { graph: u64 },
28    /// DROP GRAPH \<graph\>
29    Drop { graph: u64 },
30}
31
32/// Update executor
33pub struct UpdateExecutor<'a> {
34    pub quins: &'a mut Vec<NQuin>,
35}
36
37impl<'a> UpdateExecutor<'a> {
38    /// Creates a default `UpdateExecutor`.
39    pub fn new(quins: &'a mut Vec<NQuin>) -> Self {
40        Self { quins }
41    }
42
43    /// Execute an update operation
44    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            // Remove all matching quins
91            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        // Plan WHERE clause
110        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        // Execute WHERE clause
119        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        // Helper to evaluate a pattern against a binding row into NQuin
128        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        // In production, this would:
189        // 1. Resolve URI hash to actual URL
190        // 2. Fetch RDF from URL using HTTP client
191        // 3. Parse RDF into quins (Turtle, N-Triples, etc.)
192        // 4. Set context to graph
193        // 5. Insert quins into database
194
195        // Simplified: return 0 (requires HTTP client)
196        Ok(0)
197    }
198
199    fn execute_clear(&mut self, graph: u64) -> Result<u64, String> {
200        // Remove all quins with matching graph context
201        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        // Create a new named graph (metadata only)
208        // In production, this would:
209        // 1. Check if graph already exists
210        // 2. Create graph metadata entry
211        // 3. Set permissions/ACLs
212
213        // Simplified: return 1 (success)
214        Ok(1)
215    }
216
217    fn execute_drop(&mut self, graph: u64) -> Result<u64, String> {
218        // Remove all quins with matching graph context and delete graph metadata
219        let original_len = self.quins.len();
220        self.quins.retain(|quin| quin.context != graph);
221
222        // In production, this would also delete graph metadata
223        Ok((original_len - self.quins.len()) as u64)
224    }
225}
226
227/// Update query
228#[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}