Struct CostModel 

pub struct CostModel { /* private fields */ }

Cost model for estimating operator costs.

Default constants are calibrated relative to each other:

• Tuple scan is the baseline (1x)
• Hash lookup is ~3x (hash computation + potential cache miss)
• Sort comparison is ~2x (key extraction + comparison)
• Distance computation is ~10x (vector math)

Implementations

impl CostModel

pub fn new() -> Self

Creates a new cost model with calibrated default parameters.

pub fn with_avg_fanout(self, avg_fanout: f64) -> Self

Sets the global average fanout from graph statistics.

pub fn with_edge_type_degrees( self, degrees: HashMap<String, (f64, f64)>, ) -> Self

Sets per-edge-type degree statistics for accurate expand cost estimation.

Each entry maps edge type name to (avg_out_degree, avg_in_degree).

pub fn estimate(&self, op: &LogicalOperator, cardinality: f64) -> Cost

Estimates the cost of a logical operator.

pub fn cheaper<'a>(&self, a: &'a Cost, b: &'a Cost) -> &'a Cost

Compares two costs and returns the cheaper one.

pub fn leapfrog_join_cost( &self, num_relations: usize, cardinalities: &[f64], output_cardinality: f64, ) -> Cost

Estimates the cost of a worst-case optimal join (WCOJ/leapfrog join).

WCOJ is optimal for cyclic patterns like triangles. Traditional binary hash joins are O(N²) for triangles; WCOJ achieves O(N^1.5) by processing all relations simultaneously using sorted iterators.

Arguments

• num_relations - Number of relations participating in the join
• cardinalities - Cardinality of each input relation
• output_cardinality - Expected output cardinality

Cost Model

• Materialization: O(sum of cardinalities) to build trie indexes
• Intersection: O(output * log(min_cardinality)) for leapfrog seek operations
• Memory: Trie storage for all inputs

pub fn prefer_leapfrog_join( &self, num_relations: usize, cardinalities: &[f64], output_cardinality: f64, ) -> bool

Compares hash join cost vs leapfrog join cost for a cyclic pattern.

Returns true if leapfrog (WCOJ) is estimated to be cheaper.

pub fn factorized_benefit(&self, avg_fanout: f64, num_hops: usize) -> f64

Estimates cost for factorized execution (compressed intermediate results).

Factorized execution avoids materializing full cross products by keeping results in a compressed “factorized” form. This is beneficial for multi-hop traversals where intermediate results can explode.

Returns the reduction factor (1.0 = no benefit, lower = more compression).

Trait Implementations

impl Default for CostModel

fn default() -> Self

Returns the “default value” for a type.