Plan an INSERT statement into a logical plan
(
&mut self,
statement: &InsertStatement,
)
| 33 | |
| 34 | /// Plan an INSERT statement into a logical plan |
| 35 | pub fn plan_insert( |
| 36 | &mut self, |
| 37 | statement: &InsertStatement, |
| 38 | ) -> Result<LogicalPlan, PlanningError> { |
| 39 | log::debug!( |
| 40 | "Planning INSERT statement with {} patterns", |
| 41 | statement.graph_patterns.len() |
| 42 | ); |
| 43 | |
| 44 | let mut patterns = Vec::new(); |
| 45 | let mut variables = HashMap::new(); |
| 46 | |
| 47 | // Process all patterns to resolve identifiers and create logical patterns |
| 48 | for (pattern_idx, graph_pattern) in statement.graph_patterns.iter().enumerate() { |
| 49 | log::debug!("Processing pattern {}", pattern_idx); |
| 50 | |
| 51 | for (element_idx, element) in graph_pattern.elements.iter().enumerate() { |
| 52 | match element { |
| 53 | PatternElement::Node(node_pattern) => { |
| 54 | let logical_pattern = |
| 55 | self.process_node_pattern(node_pattern, &mut variables)?; |
| 56 | if let Some(pattern) = logical_pattern { |
| 57 | patterns.push(pattern); |
| 58 | } |
| 59 | } |
| 60 | PatternElement::Edge(edge_pattern) => { |
| 61 | let logical_patterns = self.process_edge_pattern( |
| 62 | edge_pattern, |
| 63 | &graph_pattern.elements, |
| 64 | element_idx, |
| 65 | &mut variables, |
| 66 | )?; |
| 67 | patterns.extend(logical_patterns); |
| 68 | } |
| 69 | } |
| 70 | } |
| 71 | } |
| 72 | |
| 73 | log::debug!( |
| 74 | "Created {} logical patterns with {} identifier mappings", |
| 75 | patterns.len(), |
| 76 | self.identifier_mappings.len() |
| 77 | ); |
| 78 | |
| 79 | let root = LogicalNode::Insert { |
| 80 | patterns, |
| 81 | identifier_mappings: self.identifier_mappings.clone(), |
| 82 | }; |
| 83 | |
| 84 | Ok(LogicalPlan { root, variables }) |
| 85 | } |
| 86 | |
| 87 | /// Process a node pattern element |
| 88 | fn process_node_pattern( |
no test coverage detected