Method resolve_adjacent_node

graphlite/src/plan/builders/insert_builder.rs:212–267

Resolve the node adjacent to an edge pattern

(
        &self,
        all_elements: &[PatternElement],
        edge_idx: usize,
        direction: i32, // -1 for source, +1 for target
    )

    /// Resolve the node adjacent to an edge pattern
    fn resolve_adjacent_node(
        &self,
        all_elements: &[PatternElement],
        edge_idx: usize,
        direction: i32, // -1 for source, +1 for target
    ) -> Result<String, PlanningError> {
        let node_idx = if direction < 0 {
            if edge_idx == 0 {
                return Err(PlanningError::InvalidPattern(
                    "Edge pattern must be preceded by a source node".to_string(),
                ));
            }
            edge_idx - 1
        } else {
            if edge_idx >= all_elements.len() - 1 {
                return Err(PlanningError::InvalidPattern(
                    "Edge pattern must be followed by a target node".to_string(),
                ));
            }
            edge_idx + 1
        };

        match &all_elements[node_idx] {
            PatternElement::Node(node_pattern) => {
                if let Some(ref identifier) = node_pattern.identifier {
                    // Look up the storage ID from our mappings
                    if let Some(node_info) = self.identifier_mappings.get(identifier) {
                        Ok(node_info.storage_id.clone())
                    } else {
                        Err(PlanningError::IdentifierNotFound(identifier.clone()))
                    }
                } else {
                    // Anonymous node - generate ID from content
                    let properties = if let Some(ref prop_map) = node_pattern.properties {
                        self.extract_properties(prop_map)?
                    } else {
                        HashMap::new()
                    };

                    if node_pattern.labels.is_empty() && properties.is_empty() {
                        return Err(PlanningError::InvalidPattern(
                            "Cannot use empty anonymous node in edge pattern".to_string(),
                        ));
                    }

                    Ok(Self::generate_node_content_id(
                        &node_pattern.labels,
                        &properties,
                    ))
                }
            }
            _ => Err(PlanningError::InvalidPattern(
                "Expected node pattern adjacent to edge".to_string(),
            )),
        }
    }

    /// Extract properties from a property map