Function score_triple

nodedb/src/engine/graph/pattern/optimizer.rs:96–141

Score a triple for join ordering. Lower = more selective = better. Cost = label_edge_count * bound_variable_factor - If both src and dst are already bound: factor = 0.01 (point lookup) - If one endpoint is bound: factor = 0.1 (single-node expansion) - If neither is bound: factor = 1.0 (full scan)

(
    triple: &PatternTriple,
    csr: &CsrIndex,
    bound_vars: &std::collections::HashSet<String>,
)

/// - If one endpoint is bound: factor = 0.1 (single-node expansion)
/// - If neither is bound: factor = 1.0 (full scan)
fn score_triple(
    triple: &PatternTriple,
    csr: &CsrIndex,
    bound_vars: &std::collections::HashSet<String>,
) -> f64 {
    // Base cost: label edge count (fewer = more selective).
    let label_count = triple
        .edge
        .edge_type
        .as_ref()
        .map_or(csr.edge_count(), |label| csr.label_edge_count(label));

    // If label has zero edges, this triple can't produce results — cheapest possible.
    if label_count == 0 {
        return 0.0;
    }

    let base_cost = label_count as f64;

    // Bound variable factor.
    let src_bound = triple
        .src
        .name
        .as_ref()
        .is_some_and(|n| bound_vars.contains(n));
    let dst_bound = triple
        .dst
        .name
        .as_ref()
        .is_some_and(|n| bound_vars.contains(n));

    let factor = match (src_bound, dst_bound) {
        (true, true) => 0.01,                 // Both bound: point edge check.
        (true, false) | (false, true) => 0.1, // One bound: neighborhood scan.
        (false, false) => 1.0,                // Neither bound: full label scan.
    };

    // Variable-length paths are more expensive — multiply by max_hops.
    let hop_factor = if triple.edge.is_variable_length() {
        triple.edge.max_hops as f64
    } else {
        1.0
    };

    base_cost * factor * hop_factor
}

#[cfg(test)]
mod tests {