Enum LogicalPlan 

pub enum LogicalPlan {
    Scan {
        table: String,
    },
    IndexScan {
        table: String,
        index: String,
        range_start: Option<Value>,
        range_end: Option<Value>,
        include_start: bool,
        include_end: bool,
    },
    IndexGet {
        table: String,
        index: String,
        key: Value,
    },
    IndexInGet {
        table: String,
        index: String,
        keys: Vec<Value>,
    },
    GinIndexScan {
        table: String,
        index: String,
        column: String,
        column_index: usize,
        path: String,
        value: Option<Value>,
        query_type: String,
    },
    GinIndexScanMulti {
        table: String,
        index: String,
        column: String,
        pairs: Vec<(String, Value)>,
    },
    Filter {
        input: Box<LogicalPlan>,
        predicate: Expr,
    },
    Project {
        input: Box<LogicalPlan>,
        columns: Vec<Expr>,
    },
    Join {
        left: Box<LogicalPlan>,
        right: Box<LogicalPlan>,
        condition: Expr,
        join_type: JoinType,
    },
    Aggregate {
        input: Box<LogicalPlan>,
        group_by: Vec<Expr>,
        aggregates: Vec<(AggregateFunc, Expr)>,
    },
    Sort {
        input: Box<LogicalPlan>,
        order_by: Vec<(Expr, SortOrder)>,
    },
    Limit {
        input: Box<LogicalPlan>,
        limit: usize,
        offset: usize,
    },
    CrossProduct {
        left: Box<LogicalPlan>,
        right: Box<LogicalPlan>,
    },
    Union {
        left: Box<LogicalPlan>,
        right: Box<LogicalPlan>,
        all: bool,
    },
    Empty,
}

Logical query plan node.

Variants

Scan

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

IndexGet

Index point lookup.

Fields

table: String

index: String

key: Value

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

column: String

The JSONB column being queried.

column_index: usize

The column index in the table schema.

path: String

The JSON path being queried (e.g., “$.city”).

value: Option<Value>

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

column: String

The JSONB column being queried.

pairs: Vec<(String, Value)>

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

Filter

Filter (WHERE clause).

Fields

input: Box<LogicalPlan>

predicate: Expr

Project

Projection (SELECT columns).

Fields

input: Box<LogicalPlan>

columns: Vec<Expr>

Join

Join two relations.

Fields

left: Box<LogicalPlan>

right: Box<LogicalPlan>

condition: Expr

join_type: JoinType

Aggregate

Aggregation (GROUP BY).

Fields

input: Box<LogicalPlan>

group_by: Vec<Expr>

aggregates: Vec<(AggregateFunc, Expr)>

Sort

Sort (ORDER BY).

Fields

input: Box<LogicalPlan>

order_by: Vec<(Expr, SortOrder)>

Limit

Limit and offset.

Fields

input: Box<LogicalPlan>

limit: usize

offset: usize

CrossProduct

Cross product (cartesian join).

Fields

left: Box<LogicalPlan>

right: Box<LogicalPlan>

Union

Union of two relations.

Fields

left: Box<LogicalPlan>

right: Box<LogicalPlan>

all: bool

Empty

Empty relation.

Implementations

impl LogicalPlan

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

Creates a table scan plan.

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

Creates a filter plan.

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

Creates a projection plan.

pub fn join( left: LogicalPlan, right: LogicalPlan, condition: Expr, join_type: JoinType, ) -> Self

Creates a join plan.

pub fn inner_join( left: LogicalPlan, right: LogicalPlan, condition: Expr, ) -> Self

Creates an inner join plan.

pub fn left_join(left: LogicalPlan, right: LogicalPlan, condition: Expr) -> Self

Creates a left outer join plan.

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

Creates an aggregation plan.

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

Creates a sort plan.

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

Creates a limit plan.

pub fn cross_product(left: LogicalPlan, right: LogicalPlan) -> Self

Creates a cross product plan.

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

Returns the input plan(s) of this node.

Trait Implementations

impl Clone for LogicalPlan

fn clone(&self) -> LogicalPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LogicalPlan

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

Formats the value using the given formatter.