Struct PlanCost 

pub struct PlanCost {
    pub cpu: f64,
    pub io: f64,
    pub network: f64,
    pub memory: f64,
    pub startup_cost: f64,
    pub total: f64,
}

Cost of executing a query plan.

Mirrors PostgreSQL’s Cost split: startup_cost is the work needed before the first row can be produced, total is the work to produce the last row. Both are reported so plan selection can pick a low-startup plan when a small LIMIT is in scope, even if total work is higher.

See src/storage/query/planner/README.md § Invariant 1.

Fields

cpu: f64

CPU computation cost

io: f64

IO access cost

network: f64

Network transfer cost (for distributed)

memory: f64

Memory requirement

startup_cost: f64

Cost to produce the first row.

Zero for streaming operators (full scan, index scan, filter over scan). Equal to total for blocking operators (sort, hash join build side, materialize).

total: f64

Cost to produce the last row.

Implementations

impl PlanCost

pub fn new(cpu: f64, io: f64, memory: f64) -> PlanCost

Create a new cost estimate with startup_cost = 0 (streaming).

pub fn with_startup( cpu: f64, io: f64, memory: f64, startup_cost: f64, ) -> PlanCost

Create a cost with an explicit startup_cost. Use for blocking operators (sort, hash build) and for index point lookups whose first-row cost is non-zero.

pub fn combine_pipelined(&self, other: &PlanCost) -> PlanCost

Compose two costs in a pipelined fashion: the second operator consumes the first as a stream.

Both startup_cost and total add together. Use for filter over scan, projection over filter, etc.

pub fn combine_blocking(&self, blocker: &PlanCost) -> PlanCost

Compose two costs where self must be fully consumed before blocker can produce its first row.

self.total flows into blocker.startup_cost. Use for sort, hash build, materialise — anything that has to drain its input before emitting.

pub fn combine(&self, other: &PlanCost) -> PlanCost

Backwards-compatible alias for [combine_pipelined].

New code should prefer combine_pipelined / combine_blocking explicitly. This is kept so existing callers compile unchanged.

pub fn scale(&self, factor: f64) -> PlanCost

Scale cost by a factor (cardinality multiplier, etc.).

pub fn prefer_over( &self, other: &PlanCost, limit: Option<u64>, cardinality: f64, ) -> Ordering

Plan-comparison helper. Picks Less when self should be preferred over other.

When limit is Some(k) and k < 0.1 * cardinality, the comparison switches from total to startup_cost — the client will only consume a small slice of the result, so we want the plan that produces the first rows fastest even if the full scan would be more expensive.

This mirrors PostgreSQL’s compare_path_costs_fuzzily logic for STARTUP vs TOTAL cost ordering.

Trait Implementations

impl Clone for PlanCost

fn clone(&self) -> PlanCost

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PlanCost

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for PlanCost

fn default() -> PlanCost

Returns the “default value” for a type.