Function validate_basic_query_path_patterns

graphlite/src/ast/validator.rs:979–1047

(
    query: &BasicQuery,
    _ctx: &mut ValidationContext,
    errors: &mut Vec<ValidationError>,
)

}

fn validate_basic_query_path_patterns(
    query: &BasicQuery,
    _ctx: &mut ValidationContext,
    errors: &mut Vec<ValidationError>,
) {
    for pattern in &query.match_clause.patterns {
        if pattern.elements.is_empty() {
            errors.push(ValidationError {
                message: "Path pattern cannot be empty".to_string(),
                location: None,
                error_type: ValidationErrorType::Structural,
            });
            continue;
        }

        // Check alternating pattern: Node -> Edge -> Node -> Edge -> Node
        for (i, element) in pattern.elements.iter().enumerate() {
            match element {
                PatternElement::Node(_) => {
                    // Nodes should be at even indices (0, 2, 4, ...)
                    if i % 2 != 0 {
                        errors.push(ValidationError {
                            message: format!(
                                "Invalid path pattern: expected edge at position {}",
                                i
                            ),
                            location: None,
                            error_type: ValidationErrorType::Structural,
                        });
                    }
                }
                PatternElement::Edge(_) => {
                    // Edges should be at odd indices (1, 3, 5, ...)
                    if i % 2 != 1 {
                        errors.push(ValidationError {
                            message: format!(
                                "Invalid path pattern: expected node at position {}",
                                i
                            ),
                            location: None,
                            error_type: ValidationErrorType::Structural,
                        });
                    }
                }
            }
        }

        // Validate that path starts and ends with nodes
        if let Some(first) = pattern.elements.first() {
            if matches!(first, PatternElement::Edge(_)) {
                errors.push(ValidationError {
                    message: "Path pattern must start with a node".to_string(),
                    location: None,
                    error_type: ValidationErrorType::Structural,
                });
            }
        }