Enum ResolvedExpr 

pub enum ResolvedExpr {
    Variable(VarId),
    Literal(LiteralValue),
    Property {
        expr: Box<ResolvedExpr>,
        property: String,
    },
    Binary {
        lhs: Box<ResolvedExpr>,
        op: BinaryOp,
        rhs: Box<ResolvedExpr>,
    },
    Unary {
        op: UnaryOp,
        expr: Box<ResolvedExpr>,
    },
    Function {
        function: FunctionId,
        distinct: bool,
        args: Vec<ResolvedExpr>,
    },
    List(Vec<ResolvedExpr>),
    Map(Vec<(String, ResolvedExpr)>),
    Case {
        input: Option<Box<ResolvedExpr>>,
        alternatives: Vec<(ResolvedExpr, ResolvedExpr)>,
        else_expr: Option<Box<ResolvedExpr>>,
    },
    Parameter(String),
    ListPredicate {
        kind: ListPredicateKind,
        variable: VarId,
        list: Box<ResolvedExpr>,
        predicate: Box<ResolvedExpr>,
    },
    ListComprehension {
        variable: VarId,
        list: Box<ResolvedExpr>,
        filter: Option<Box<ResolvedExpr>>,
        map_expr: Option<Box<ResolvedExpr>>,
    },
    Reduce {
        accumulator: VarId,
        init: Box<ResolvedExpr>,
        variable: VarId,
        list: Box<ResolvedExpr>,
        expr: Box<ResolvedExpr>,
    },
    MapProjection {
        base: Box<ResolvedExpr>,
        selectors: Vec<ResolvedMapSelector>,
    },
    Index {
        expr: Box<ResolvedExpr>,
        index: Box<ResolvedExpr>,
    },
    Slice {
        expr: Box<ResolvedExpr>,
        from: Option<Box<ResolvedExpr>>,
        to: Option<Box<ResolvedExpr>>,
    },
    ExistsSubquery {
        pattern: ResolvedPattern,
        where_: Option<Box<ResolvedExpr>>,
        reads: Vec<VarId>,
    },
    PatternComprehension {
        pattern: ResolvedPattern,
        where_: Option<Box<ResolvedExpr>>,
        map_expr: Box<ResolvedExpr>,
        reads: Vec<VarId>,
    },
}

Variants

Variable(VarId)

Literal(LiteralValue)

Property

Fields

expr: Box<ResolvedExpr>

property: String

Binary

Fields

lhs: Box<ResolvedExpr>

op: BinaryOp

rhs: Box<ResolvedExpr>

Unary

Fields

op: UnaryOp

expr: Box<ResolvedExpr>

Function

Fields

function: FunctionId

distinct: bool

args: Vec<ResolvedExpr>

List(Vec<ResolvedExpr>)

Map(Vec<(String, ResolvedExpr)>)

Case

Fields

input: Option<Box<ResolvedExpr>>

alternatives: Vec<(ResolvedExpr, ResolvedExpr)>

else_expr: Option<Box<ResolvedExpr>>

Parameter(String)

ListPredicate

Fields

kind: ListPredicateKind

variable: VarId

list: Box<ResolvedExpr>

predicate: Box<ResolvedExpr>

ListComprehension

Fields

variable: VarId

list: Box<ResolvedExpr>

filter: Option<Box<ResolvedExpr>>

map_expr: Option<Box<ResolvedExpr>>

Reduce

Fields

accumulator: VarId

init: Box<ResolvedExpr>

variable: VarId

list: Box<ResolvedExpr>

expr: Box<ResolvedExpr>

MapProjection

Fields

base: Box<ResolvedExpr>

selectors: Vec<ResolvedMapSelector>

Index

Fields

expr: Box<ResolvedExpr>

index: Box<ResolvedExpr>

Slice

Fields

expr: Box<ResolvedExpr>

from: Option<Box<ResolvedExpr>>

to: Option<Box<ResolvedExpr>>

ExistsSubquery

Fields

pattern: ResolvedPattern

where_: Option<Box<ResolvedExpr>>

reads: Vec<VarId>

Every variable the pattern and WHERE use (see ResolvedExpr::collect_vars), sorted: the outer bindings the subquery can read, computed once so evaluation need not walk it.

PatternComprehension

Fields

pattern: ResolvedPattern

where_: Option<Box<ResolvedExpr>>

map_expr: Box<ResolvedExpr>

reads: Vec<VarId>

Every variable the pattern, WHERE and projection use, as for ResolvedExpr::ExistsSubquery.

Implementations

impl ResolvedExpr

pub fn collect_vars(&self, out: &mut BTreeSet<VarId>)

Every variable the expression reads. Patterns inside it (EXISTS, pattern comprehensions) contribute the outer variables they name and their own fresh ones: an over-approximation, which is safe for every caller (it only ever keeps a predicate in place, or a binding in a row).

Trait Implementations

impl Clone for ResolvedExpr

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResolvedExpr

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

Formats the value using the given formatter.