Enum LogicalPlan 

pub enum LogicalPlan {
    Scan {
        table: String,
        projection: Projection,
    },
    Filter {
        input: Box<LogicalPlan>,
        predicate: TypedExpr,
    },
    Aggregate {
        input: Box<LogicalPlan>,
        group_keys: Vec<TypedExpr>,
        aggregates: Vec<AggregateExpr>,
        having: Option<TypedExpr>,
    },
    Sort {
        input: Box<LogicalPlan>,
        order_by: Vec<SortExpr>,
    },
    Limit {
        input: Box<LogicalPlan>,
        limit: Option<u64>,
        offset: Option<u64>,
    },
    Insert {
        table: String,
        columns: Vec<String>,
        values: Vec<Vec<TypedExpr>>,
    },
    Update {
        table: String,
        assignments: Vec<TypedAssignment>,
        filter: Option<TypedExpr>,
    },
    Delete {
        table: String,
        filter: Option<TypedExpr>,
    },
    CreateTable {
        table: TableMetadata,
        if_not_exists: bool,
        with_options: Vec<(String, String)>,
    },
    DropTable {
        name: String,
        if_exists: bool,
    },
    CreateIndex {
        index: IndexMetadata,
        if_not_exists: bool,
    },
    DropIndex {
        name: String,
        if_exists: bool,
    },
}

Logical query plan representation.

This enum represents all possible logical operations that can be performed. Plans are organized into three categories:

1. Query Plans: Read operations (Scan, Filter, Sort, Limit)
2. DML Plans: Data modification (Insert, Update, Delete)
3. DDL Plans: Schema modification (CreateTable, DropTable, CreateIndex, DropIndex)

Variants

Scan

Table scan operation.

Scans all rows from a table with the specified projection. This is typically the leaf node of query plans.

Fields

table: String

Table name to scan.

projection: Projection

Columns to project (after wildcard expansion).

Filter

Filter operation (WHERE clause).

Filters rows from the input plan based on a predicate.

Fields

input: Box<LogicalPlan>

Input plan to filter.

predicate: TypedExpr

Filter predicate (must evaluate to Boolean).

Aggregate

Aggregate operation (GROUP BY / aggregation).

Aggregates rows from the input plan using group keys and aggregate expressions.

Fields

input: Box<LogicalPlan>

Input plan to aggregate.

group_keys: Vec<TypedExpr>

Group-by key expressions (empty for global aggregation).

aggregates: Vec<AggregateExpr>

Aggregate expressions to compute.

having: Option<TypedExpr>

HAVING filter applied after aggregation.

Sort

Sort operation (ORDER BY clause).

Sorts rows from the input plan based on sort expressions.

Fields

input: Box<LogicalPlan>

Input plan to sort.

order_by: Vec<SortExpr>

Sort expressions with direction.

Limit

Limit operation (LIMIT/OFFSET clause).

Limits the number of rows from the input plan.

Fields

input: Box<LogicalPlan>

Input plan to limit.

limit: Option<u64>

Maximum number of rows to return.

offset: Option<u64>

Number of rows to skip.

Insert

INSERT operation.

Inserts one or more rows into a table. When columns are omitted in the SQL statement, the Planner fills in all columns from TableMetadata in definition order.

Fields

table: String

Target table name.

columns: Vec<String>

Column names (always populated, never empty). If omitted in SQL, filled from TableMetadata.column_names().

values: Vec<Vec<TypedExpr>>

Values to insert (one Vec per row, each value corresponds to a column).

Update

UPDATE operation.

Updates rows in a table that match an optional filter.

Fields

table: String

Target table name.

assignments: Vec<TypedAssignment>

Assignments (SET column = value).

filter: Option<TypedExpr>

Optional filter predicate (WHERE clause).

Delete

DELETE operation.

Deletes rows from a table that match an optional filter.

Fields

table: String

Target table name.

filter: Option<TypedExpr>

Optional filter predicate (WHERE clause).

CreateTable

CREATE TABLE operation.

Creates a new table with the specified metadata.

Fields

table: TableMetadata

Table metadata (name, columns, constraints).

if_not_exists: bool

If true, don’t error if table already exists.

with_options: Vec<(String, String)>

Raw WITH options to be validated during execution.

DropTable

DROP TABLE operation.

Drops an existing table.

Fields

name: String

Table name to drop.

if_exists: bool

If true, don’t error if table doesn’t exist.

CreateIndex

CREATE INDEX operation.

Creates a new index on a table column.

Fields

index: IndexMetadata

Index metadata (name, table, column, method, options).

if_not_exists: bool

If true, don’t error if index already exists.

DropIndex

DROP INDEX operation.

Drops an existing index.

Fields

name: String

Index name to drop.

if_exists: bool

If true, don’t error if index doesn’t exist.

Implementations

impl LogicalPlan

pub fn operation_name(&self) -> &'static str

pub fn scan(table: String, projection: Projection) -> Self

Creates a new Scan plan.

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

Creates a new Filter plan.

pub fn aggregate( input: LogicalPlan, group_keys: Vec<TypedExpr>, aggregates: Vec<AggregateExpr>, having: Option<TypedExpr>, ) -> Self

Creates a new Aggregate plan.

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

Creates a new Sort plan.

pub fn limit( input: LogicalPlan, limit: Option<u64>, offset: Option<u64>, ) -> Self

Creates a new Limit plan.

pub fn insert( table: String, columns: Vec<String>, values: Vec<Vec<TypedExpr>>, ) -> Self

Creates a new Insert plan.

pub fn update( table: String, assignments: Vec<TypedAssignment>, filter: Option<TypedExpr>, ) -> Self

Creates a new Update plan.

pub fn delete(table: String, filter: Option<TypedExpr>) -> Self

Creates a new Delete plan.

pub fn create_table( table: TableMetadata, if_not_exists: bool, with_options: Vec<(String, String)>, ) -> Self

Creates a new CreateTable plan.

pub fn drop_table(name: String, if_exists: bool) -> Self

Creates a new DropTable plan.

pub fn create_index(index: IndexMetadata, if_not_exists: bool) -> Self

Creates a new CreateIndex plan.

pub fn drop_index(name: String, if_exists: bool) -> Self

Creates a new DropIndex plan.

pub fn name(&self) -> &'static str

Returns the name of this plan variant.

pub fn is_query(&self) -> bool

Returns true if this is a query plan (Scan, Filter, Sort, Limit).

pub fn is_dml(&self) -> bool

Returns true if this is a DML plan (Insert, Update, Delete).

pub fn is_ddl(&self) -> bool

Returns true if this is a DDL plan (CreateTable, DropTable, CreateIndex, DropIndex).

pub fn input(&self) -> Option<&LogicalPlan>

Returns the input plan if this is a transformation (Filter, Aggregate, Sort, Limit).

pub fn table_name(&self) -> Option<&str>

Returns the table name if this plan operates on a single table.

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.