Enum PhysicalPlan 

pub enum PhysicalPlan {
    TableScan {
        table: String,
    },
    IndexScan {
        table: String,
        index: String,
        range_start: Option<Value>,
        range_end: Option<Value>,
        include_start: bool,
        include_end: bool,
        limit: Option<usize>,
        offset: Option<usize>,
        reverse: bool,
    },
    IndexGet {
        table: String,
        index: String,
        key: Value,
        limit: Option<usize>,
    },
    IndexInGet {
        table: String,
        index: String,
        keys: Vec<Value>,
    },
    GinIndexScan {
        table: String,
        index: String,
        key: String,
        value: Option<String>,
        query_type: String,
    },
    GinIndexScanMulti {
        table: String,
        index: String,
        pairs: Vec<(String, String)>,
    },
    Filter {
        input: Box<PhysicalPlan>,
        predicate: Expr,
    },
    Project {
        input: Box<PhysicalPlan>,
        columns: Vec<Expr>,
    },
    HashJoin {
        left: Box<PhysicalPlan>,
        right: Box<PhysicalPlan>,
        condition: Expr,
        join_type: JoinType,
    },
    SortMergeJoin {
        left: Box<PhysicalPlan>,
        right: Box<PhysicalPlan>,
        condition: Expr,
        join_type: JoinType,
    },
    NestedLoopJoin {
        left: Box<PhysicalPlan>,
        right: Box<PhysicalPlan>,
        condition: Expr,
        join_type: JoinType,
    },
    IndexNestedLoopJoin {
        outer: Box<PhysicalPlan>,
        inner_table: String,
        inner_index: String,
        condition: Expr,
        join_type: JoinType,
    },
    HashAggregate {
        input: Box<PhysicalPlan>,
        group_by: Vec<Expr>,
        aggregates: Vec<(AggregateFunc, Expr)>,
    },
    Sort {
        input: Box<PhysicalPlan>,
        order_by: Vec<(Expr, SortOrder)>,
    },
    TopN {
        input: Box<PhysicalPlan>,
        order_by: Vec<(Expr, SortOrder)>,
        limit: usize,
        offset: usize,
    },
    Limit {
        input: Box<PhysicalPlan>,
        limit: usize,
        offset: usize,
    },
    CrossProduct {
        left: Box<PhysicalPlan>,
        right: Box<PhysicalPlan>,
    },
    NoOp {
        input: Box<PhysicalPlan>,
    },
    Empty,
}

Physical query plan node.

Variants

TableScan

Full table scan.

Fields

table: String

IndexScan

Index scan with a key range.

Fields

table: String

index: String

range_start: Option<Value>

range_end: Option<Value>

include_start: bool

include_end: bool

limit: Option<usize>

Optional limit for early termination.

offset: Option<usize>

Optional offset to skip rows.

reverse: bool

Whether to scan in reverse order (for DESC sorting).

IndexGet

Index point lookup.

Fields

table: String

index: String

key: Value

limit: Option<usize>

Optional limit for early termination.

IndexInGet

Index multi-point lookup (for IN queries). Performs multiple index lookups and unions the results.

Fields

table: String

index: String

keys: Vec<Value>

GinIndexScan

GIN index scan for JSONB queries.

Fields

table: String

index: String

key: String

The key to search for (JSON path segment).

value: Option<String>

The value to match (for equality queries).

query_type: String

Query type: “eq”, “contains”, or “exists”.

GinIndexScanMulti

GIN index scan for multiple JSONB predicates (AND combination). More efficient than multiple single GIN scans followed by intersection.

Fields

table: String

index: String

pairs: Vec<(String, String)>

Multiple key-value pairs to match (all must match - AND semantics).

Filter

Filter operator.

Fields

input: Box<PhysicalPlan>

predicate: Expr

Project

Projection operator.

Fields

input: Box<PhysicalPlan>

columns: Vec<Expr>

HashJoin

Hash join.

Fields

left: Box<PhysicalPlan>

right: Box<PhysicalPlan>

condition: Expr

join_type: JoinType

SortMergeJoin

Sort-merge join.

Fields

left: Box<PhysicalPlan>

right: Box<PhysicalPlan>

condition: Expr

join_type: JoinType

NestedLoopJoin

Nested loop join.

Fields

left: Box<PhysicalPlan>

right: Box<PhysicalPlan>

condition: Expr

join_type: JoinType

IndexNestedLoopJoin

Index nested loop join.

Fields

outer: Box<PhysicalPlan>

inner_table: String

inner_index: String

condition: Expr

join_type: JoinType

HashAggregate

Hash aggregate.

Fields

input: Box<PhysicalPlan>

group_by: Vec<Expr>

aggregates: Vec<(AggregateFunc, Expr)>

Sort

Sort operator.

Fields

input: Box<PhysicalPlan>

order_by: Vec<(Expr, SortOrder)>

TopN

TopN operator - combines Sort and Limit for efficient top-k selection. Uses a heap to maintain only the top N elements, avoiding full sort.

Fields

input: Box<PhysicalPlan>

order_by: Vec<(Expr, SortOrder)>

limit: usize

offset: usize

Limit

Limit and offset.

Fields

input: Box<PhysicalPlan>

limit: usize

offset: usize

CrossProduct

Cross product.

Fields

left: Box<PhysicalPlan>

right: Box<PhysicalPlan>

NoOp

No-op step (passes through input).

Fields

input: Box<PhysicalPlan>

Empty

Empty result.

Implementations

impl PhysicalPlan

pub fn table_scan(table: impl Into<String>) -> Self

Creates a table scan plan.

pub fn index_scan( table: impl Into<String>, index: impl Into<String>, range_start: Option<Value>, range_end: Option<Value>, ) -> Self

Creates an index scan plan.

pub fn index_scan_with_limit( table: impl Into<String>, index: impl Into<String>, range_start: Option<Value>, range_end: Option<Value>, limit: Option<usize>, offset: Option<usize>, ) -> Self

Creates an index scan plan with limit and offset.

pub fn index_scan_with_options( table: impl Into<String>, index: impl Into<String>, range_start: Option<Value>, range_end: Option<Value>, limit: Option<usize>, offset: Option<usize>, reverse: bool, ) -> Self

Creates an index scan plan with limit, offset, and reverse option.

pub fn index_get( table: impl Into<String>, index: impl Into<String>, key: Value, ) -> Self

Creates an index point lookup plan.

pub fn index_get_with_limit( table: impl Into<String>, index: impl Into<String>, key: Value, limit: Option<usize>, ) -> Self

Creates an index point lookup plan with limit.

pub fn index_in_get( table: impl Into<String>, index: impl Into<String>, keys: Vec<Value>, ) -> Self

Creates an index multi-point lookup plan (for IN queries).

pub fn gin_index_scan( table: impl Into<String>, index: impl Into<String>, key: impl Into<String>, value: Option<String>, query_type: impl Into<String>, ) -> Self

Creates a GIN index scan plan.

pub fn gin_index_scan_multi( table: impl Into<String>, index: impl Into<String>, pairs: Vec<(String, String)>, ) -> Self

Creates a GIN index scan plan for multiple key-value pairs (AND combination).

pub fn filter(input: PhysicalPlan, predicate: Expr) -> Self

Creates a filter plan.

pub fn project(input: PhysicalPlan, columns: Vec<Expr>) -> Self

Creates a projection plan.

pub fn hash_join( left: PhysicalPlan, right: PhysicalPlan, condition: Expr, join_type: JoinType, ) -> Self

Creates a hash join plan.

pub fn sort_merge_join( left: PhysicalPlan, right: PhysicalPlan, condition: Expr, join_type: JoinType, ) -> Self

Creates a sort-merge join plan.

pub fn nested_loop_join( left: PhysicalPlan, right: PhysicalPlan, condition: Expr, join_type: JoinType, ) -> Self

Creates a nested loop join plan.

pub fn hash_aggregate( input: PhysicalPlan, group_by: Vec<Expr>, aggregates: Vec<(AggregateFunc, Expr)>, ) -> Self

Creates a hash aggregate plan.

pub fn sort(input: PhysicalPlan, order_by: Vec<(Expr, SortOrder)>) -> Self

Creates a sort plan.

pub fn top_n( input: PhysicalPlan, order_by: Vec<(Expr, SortOrder)>, limit: usize, offset: usize, ) -> Self

Creates a TopN plan for efficient top-k selection.

pub fn limit(input: PhysicalPlan, limit: usize, offset: usize) -> Self

Creates a limit plan.

pub fn is_incrementalizable(&self) -> bool

Checks if this plan can be incrementalized.

pub fn inputs(&self) -> Vec<&PhysicalPlan>

Returns the input plan(s) of this node.

Trait Implementations

impl Clone for PhysicalPlan

fn clone(&self) -> PhysicalPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PhysicalPlan

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

Formats the value using the given formatter.