Enum LogicalPlan 

pub enum LogicalPlan {
    Scan {
        table: Arc<Table>,
        alias: Option<String>,
        projection: Option<Vec<usize>>,
        filter: Option<Expr>,
    },
    IndexScan {
        table: Arc<Table>,
        alias: Option<String>,
        index: Index,
        index_column: usize,
        range: IndexRange,
        residual_filter: Option<Expr>,
        projection: Option<Vec<usize>>,
    },
    PkSeek {
        table: Arc<Table>,
        alias: Option<String>,
        key_values: Vec<Expr>,
        residual_filter: Option<Expr>,
        projection: Option<Vec<usize>>,
    },
    PkRangeScan {
        table: Arc<Table>,
        alias: Option<String>,
        range: IndexRange,
        residual_filter: Option<Expr>,
        projection: Option<Vec<usize>>,
    },
    Filter {
        input: Box<LogicalPlan>,
        predicate: Expr,
    },
    Project {
        input: Box<LogicalPlan>,
        exprs: Vec<(Expr, String)>,
    },
    Join {
        left: Box<LogicalPlan>,
        right: Box<LogicalPlan>,
        join_type: JoinType,
        condition: Option<Expr>,
    },
    Aggregate {
        input: Box<LogicalPlan>,
        group_by: Vec<Expr>,
        aggregates: Vec<(Expr, String)>,
    },
    Sort {
        input: Box<LogicalPlan>,
        order_by: Vec<(Expr, SortOrder)>,
    },
    Limit {
        input: Box<LogicalPlan>,
        limit: Option<usize>,
        offset: usize,
    },
    Distinct {
        input: Box<LogicalPlan>,
    },
    Insert {
        table: Arc<Table>,
        columns: Vec<String>,
        values: Vec<Vec<Expr>>,
    },
    Update {
        table: Arc<Table>,
        assignments: Vec<(String, Expr)>,
        filter: Option<Expr>,
    },
    Delete {
        table: Arc<Table>,
        filter: Option<Expr>,
    },
    CreateTable {
        table: Table,
    },
    DropTable {
        name: String,
        if_exists: bool,
    },
    EmptyRelation,
    Explain {
        input: Box<LogicalPlan>,
        verbose: bool,
        analyze: bool,
    },
    Window {
        input: Box<LogicalPlan>,
        window_exprs: Vec<(Expr, String)>,
    },
    AlterTable {
        table_name: String,
        operations: Vec<AlterTableOp>,
    },
    WithCte {
        ctes: Vec<CommonTableExpression>,
        query: Box<LogicalPlan>,
    },
    CteScan {
        cte_name: String,
        alias: Option<String>,
        columns: Vec<String>,
    },
    SubqueryScan {
        subquery: Box<LogicalPlan>,
        subquery_id: usize,
        alias: Option<String>,
    },
    SemiJoin {
        left: Box<LogicalPlan>,
        right: Box<LogicalPlan>,
        condition: Option<Expr>,
        positive: bool,
    },
    AntiJoin {
        left: Box<LogicalPlan>,
        right: Box<LogicalPlan>,
        condition: Option<Expr>,
    },
    Grant {
        privileges: Permissions,
        table: Option<String>,
        grantee: String,
    },
    Revoke {
        privileges: Permissions,
        table: Option<String>,
        grantee: String,
    },
    ShowGrants {
        target: ShowGrantsTarget,
    },
    Union {
        left: Box<LogicalPlan>,
        right: Box<LogicalPlan>,
        all: bool,
    },
    Intersect {
        left: Box<LogicalPlan>,
        right: Box<LogicalPlan>,
        all: bool,
    },
    Except {
        left: Box<LogicalPlan>,
        right: Box<LogicalPlan>,
        all: bool,
    },
    CreateView {
        name: String,
        query: Box<LogicalPlan>,
        query_sql: String,
        columns: Vec<String>,
    },
    DropView {
        name: String,
        if_exists: bool,
    },
    CreateIndex {
        index_name: String,
        table_name: String,
        columns: Vec<String>,
        unique: bool,
    },
}

Logical plan - represents a query as a tree of relational operators

Variants

Scan

Scan a table

Fields

table: Arc<Table>

alias: Option<String>

projection: Option<Vec<usize>>

filter: Option<Expr>

IndexScan

Index scan - uses an index for efficient lookups This provides 100-1000x speedup for indexed queries

Fields

table: Arc<Table>

Table being scanned

alias: Option<String>

Table alias

index: Index

Index to use for the scan

index_column: usize

Column index in the table that the index covers (for single-column indexes)

range: IndexRange

Range to scan in the index

residual_filter: Option<Expr>

Additional filter for non-indexed predicates Applied after index lookup

projection: Option<Vec<usize>>

Projection columns

PkSeek

Direct primary key lookup - O(log N) instead of O(N) scan Used when ALL primary key columns have equality predicates

Fields

table: Arc<Table>

alias: Option<String>

key_values: Vec<Expr>

One expression per PK column, in PK order

residual_filter: Option<Expr>

Non-PK predicates applied after lookup

projection: Option<Vec<usize>>

Projection columns

PkRangeScan

Direct primary key range scan - O(range_size) instead of O(N) Used when PK column has range predicates (>=, >, <=, <)

Fields

table: Arc<Table>

alias: Option<String>

range: IndexRange

Range bounds for PK scan

residual_filter: Option<Expr>

Non-PK predicates applied after lookup

projection: Option<Vec<usize>>

Projection columns

Filter

Filter rows

Fields

input: Box<LogicalPlan>

predicate: Expr

Project

Project columns

Fields

input: Box<LogicalPlan>

exprs: Vec<(Expr, String)>

Join

Join two inputs

Fields

left: Box<LogicalPlan>

right: Box<LogicalPlan>

join_type: JoinType

condition: Option<Expr>

Aggregate

Aggregate

Fields

input: Box<LogicalPlan>

group_by: Vec<Expr>

aggregates: Vec<(Expr, String)>

Sort

Sort

Fields

input: Box<LogicalPlan>

order_by: Vec<(Expr, SortOrder)>

Limit

Limit output rows

Fields

input: Box<LogicalPlan>

limit: Option<usize>

offset: usize

Distinct

Distinct

Fields

input: Box<LogicalPlan>

Insert

Insert rows

Fields

table: Arc<Table>

columns: Vec<String>

values: Vec<Vec<Expr>>

Update

Update rows

Fields

table: Arc<Table>

assignments: Vec<(String, Expr)>

filter: Option<Expr>

Delete

Delete rows

Fields

table: Arc<Table>

filter: Option<Expr>

CreateTable

Create table

Fields

table: Table

DropTable

Drop table

Fields

name: String

if_exists: bool

EmptyRelation

Empty relation (for queries with no FROM)

Explain

Explain plan - shows query execution plan with cost estimates

Fields

input: Box<LogicalPlan>

The plan to explain

verbose: bool

Whether to show detailed costs

analyze: bool

Whether to actually run the query and show execution stats

Window

Window function evaluation

Fields

input: Box<LogicalPlan>

Input plan

window_exprs: Vec<(Expr, String)>

Window function expressions with their output aliases

AlterTable

Alter table schema

Fields

table_name: String

Name of the table to alter

operations: Vec<AlterTableOp>

Operations to perform

WithCte

Common Table Expression (CTE) - WITH clause Materializes CTE results and makes them available as virtual tables

Fields

ctes: Vec<CommonTableExpression>

CTE definitions (name, columns, plan, is_recursive)

query: Box<LogicalPlan>

The main query that uses the CTEs

CteScan

Scan a CTE by name

Fields

cte_name: String

Name of the CTE being scanned

alias: Option<String>

Table alias (e.g. eng_dept e1 → alias = Some(“e1”))

columns: Vec<String>

Output column names (bare, without prefix)

SubqueryScan

Subquery scan - executes a subquery and provides its results

Fields

subquery: Box<LogicalPlan>

The subquery plan

subquery_id: usize

Unique identifier for tracking

alias: Option<String>

Output alias

SemiJoin

Semi-join - optimized execution for EXISTS/IN subqueries Returns rows from left where at least one matching row exists in right

Fields

left: Box<LogicalPlan>

right: Box<LogicalPlan>

condition: Option<Expr>

positive: bool

True for EXISTS, false for NOT EXISTS / NOT IN

AntiJoin

Anti-join - returns rows from left where NO matching row exists in right Used for NOT IN / NOT EXISTS optimization

Fields

left: Box<LogicalPlan>

right: Box<LogicalPlan>

condition: Option<Expr>

Grant

Grant permissions on a table to an API key (v0.4.0)

Fields

privileges: Permissions

Permissions to grant (SELECT, INSERT, UPDATE, DELETE, ALL)

table: Option<String>

Table name, or None for wildcard (all tables)

grantee: String

The API key ID to grant permissions to

Revoke

Revoke permissions from an API key (v0.4.0)

Fields

privileges: Permissions

Permissions to revoke (SELECT, INSERT, UPDATE, DELETE, ALL)

table: Option<String>

Table name, or None for wildcard (all tables)

grantee: String

The API key ID to revoke permissions from

ShowGrants

Show grants for a table or API key (v0.4.0)

Fields

target: ShowGrantsTarget

Target of SHOW GRANTS query

Union

UNION / UNION ALL - combines results of two queries

Fields

left: Box<LogicalPlan>

right: Box<LogicalPlan>

all: bool

If true, keep duplicates (UNION ALL). If false, deduplicate (UNION).

Intersect

INTERSECT / INTERSECT ALL - returns rows common to both queries

Fields

left: Box<LogicalPlan>

right: Box<LogicalPlan>

all: bool

If true, keep duplicates (INTERSECT ALL). If false, deduplicate.

Except

EXCEPT / EXCEPT ALL - returns rows in left but not in right

Fields

left: Box<LogicalPlan>

right: Box<LogicalPlan>

all: bool

If true, keep duplicates (EXCEPT ALL). If false, deduplicate.

CreateView

CREATE VIEW - stores a named query definition

Fields

name: String

query: Box<LogicalPlan>

query_sql: String

The original SQL of the view query (for re-planning on scan)

columns: Vec<String>

Column aliases for the view

DropView

DROP VIEW

Fields

name: String

if_exists: bool

CreateIndex

CREATE INDEX

Fields

index_name: String

table_name: String

columns: Vec<String>

unique: bool

Implementations

impl LogicalPlan

pub fn output_columns(&self) -> Vec<String>

Get output column names

pub fn collect_column_references(&self) -> Vec<(Option<String>, String)>

Collect all column references from expressions in the plan Returns tuples of (table, column_name)

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.