Method process_node_pattern

graphlite/src/plan/builders/insert_builder.rs:88–146

Process a node pattern element

(
        &mut self,
        node_pattern: &crate::ast::Node,
        variables: &mut HashMap<String, VariableInfo>,
    )

    /// Process a node pattern element
    fn process_node_pattern(
        &mut self,
        node_pattern: &crate::ast::Node,
        variables: &mut HashMap<String, VariableInfo>,
    ) -> Result<Option<InsertPattern>, PlanningError> {
        // Check if this is a reference to an already-defined node
        if let Some(ref identifier) = node_pattern.identifier {
            if self.defined_identifiers.contains(identifier) {
                log::debug!(
                    "Node '{}' is a reference to existing definition, skipping node creation",
                    identifier
                );
                return Ok(None); // This is a reference, not a new node
            }
        }

        // Extract properties
        let properties = if let Some(ref prop_map) = node_pattern.properties {
            self.extract_properties(prop_map)?
        } else {
            HashMap::new()
        };

        // Generate content-based storage ID
        let storage_id = Self::generate_node_content_id(&node_pattern.labels, &properties);

        // If there's an identifier, add it to our mappings and mark as defined
        if let Some(ref identifier) = node_pattern.identifier {
            self.identifier_mappings.insert(
                identifier.clone(),
                NodeIdentifier {
                    storage_id: storage_id.clone(),
                    labels: node_pattern.labels.clone(),
                    is_reference: false,
                },
            );
            self.defined_identifiers.insert(identifier.clone());

            // Add to variables
            variables.insert(
                identifier.clone(),
                VariableInfo {
                    name: identifier.clone(),
                    entity_type: EntityType::Node,
                    labels: node_pattern.labels.clone(),
                    required_properties: properties.keys().cloned().collect(),
                },
            );
        }

        log::debug!("Creating node pattern with storage_id: {}", storage_id);

        Ok(Some(InsertPattern::CreateNode {
            storage_id,
            labels: node_pattern.labels.clone(),
            properties,
            original_identifier: node_pattern.identifier.clone(),
        }))