Enum risinglight::planner::Expr

pub enum Expr {
    Constant(DataValue),
    Type(DataTypeKind),
    Column(ColumnRefId),
    Table(TableRefId),
    ColumnIndex(ColumnIndex),
    ExtSource(ExtSource),
    Nested(Id),
    List(Box<[Id]>),
    Add([Id; 2]),
    Sub([Id; 2]),
    Mul([Id; 2]),
    Div([Id; 2]),
    Mod([Id; 2]),
    StringConcat([Id; 2]),
    Gt([Id; 2]),
    Lt([Id; 2]),
    GtEq([Id; 2]),
    LtEq([Id; 2]),
    Eq([Id; 2]),
    NotEq([Id; 2]),
    And([Id; 2]),
    Or([Id; 2]),
    Xor([Id; 2]),
    Like([Id; 2]),
    Neg(Id),
    Not(Id),
    IsNull(Id),
    If([Id; 3]),
    Max(Id),
    Min(Id),
    Sum(Id),
    Avg(Id),
    Count(Id),
    RowCount,
    First(Id),
    Last(Id),
    Exists(Id),
    In([Id; 2]),
    Cast([Id; 2]),
    Scan([Id; 2]),
    Values(Box<[Id]>),
    Proj([Id; 2]),
    Filter([Id; 2]),
    Order([Id; 2]),
    Asc(Id),
    Desc(Id),
    Limit([Id; 3]),
    TopN([Id; 4]),
    Join([Id; 4]),
    HashJoin([Id; 5]),
    Inner,
    LeftOuter,
    RightOuter,
    FullOuter,
    Agg([Id; 3]),
    CreateTable(CreateTable),
    Drop(BoundDrop),
    Insert([Id; 3]),
    Delete([Id; 2]),
    CopyFrom([Id; 2]),
    CopyTo([Id; 2]),
    Explain(Id),
    Prune([Id; 2]),
    Empty(Box<[Id]>),
    Symbol(Symbol),
}

Variants

Constant(DataValue)

Type(DataTypeKind)

Column(ColumnRefId)

Table(TableRefId)

ColumnIndex(ColumnIndex)

ExtSource(ExtSource)

Nested(Id)

List(Box<[Id]>)

Add([Id; 2])

Sub([Id; 2])

Mul([Id; 2])

Div([Id; 2])

Mod([Id; 2])

StringConcat([Id; 2])

Gt([Id; 2])

Lt([Id; 2])

GtEq([Id; 2])

LtEq([Id; 2])

Eq([Id; 2])

NotEq([Id; 2])

And([Id; 2])

Or([Id; 2])

Xor([Id; 2])

Like([Id; 2])

Neg(Id)

Not(Id)

IsNull(Id)

If([Id; 3])

Max(Id)

Min(Id)

Sum(Id)

Avg(Id)

Count(Id)

RowCount

First(Id)

Last(Id)

Exists(Id)

In([Id; 2])

Cast([Id; 2])

Scan([Id; 2])

Values(Box<[Id]>)

Proj([Id; 2])

Filter([Id; 2])

Order([Id; 2])

Asc(Id)

Desc(Id)

Limit([Id; 3])

TopN([Id; 4])

Join([Id; 4])

HashJoin([Id; 5])

Inner

LeftOuter

RightOuter

FullOuter

Agg([Id; 3])

CreateTable(CreateTable)

Drop(BoundDrop)

Insert([Id; 3])

Delete([Id; 2])

CopyFrom([Id; 2])

CopyTo([Id; 2])

Explain(Id)

Prune([Id; 2])

Empty(Box<[Id]>)

Symbol(Symbol)

Implementations

impl Expr

pub const fn true_() -> Self

pub const fn null() -> Self

pub const fn zero() -> Self

pub fn as_const(&self) -> DataValue

pub fn as_list(&self) -> &[Id]

pub fn as_column(&self) -> ColumnRefId

pub fn as_table(&self) -> TableRefId

pub fn as_type(&self) -> &DataTypeKind

pub fn as_ext_source(&self) -> ExtSource

pub const fn binary_op(&self) -> Option<(BinaryOperator, Id, Id)>

pub const fn unary_op(&self) -> Option<(UnaryOperator, Id)>

Trait Implementations

impl Analysis<Expr> for ExprAnalysis

fn make(egraph: &EGraph<Expr, ExprAnalysis>, enode: &Expr) -> Self::Data

Analyze a node and give the result.

fn merge(&mut self, to: &mut Self::Data, from: Self::Data) -> DidMerge

Merge the analysis data with previous one.

This process makes the analysis data more accurate.

For example, if we have an expr a + 1 - a, the constant analysis will give a result None since we are not sure if it is a constant or not. But after we applied a rule and turned it to a - a + 1 -> 0 + 1, we know it is a constant. Then in this function, we merge the new result Some(1) with the previous None and keep Some(1) as the final result.

fn modify(egraph: &mut EGraph<Expr, ExprAnalysis>, id: Id)

Modify the graph after analyzing a node.

type Data = Data

The per-EClass data for this analysis.

fn pre_union(
    egraph: &EGraph<L, Self>,
    id1: Id,
    id2: Id,
    justification: &Option<Justification>
)

An optional hook that allows inspection before a union occurs. When explanations are enabled, it gives two ids that represent the two particular terms being unioned, not the canonical ids for the two eclasses. It also gives a justification for the union when explanations are enabled.

impl Analysis<Expr> for TypeSchemaAnalysis

type Data = TypeSchema

The per-EClass data for this analysis.

fn make(egraph: &EGraph<Expr, Self>, enode: &Expr) -> Self::Data

Makes a new Analysis for a given enode Analysis.

fn merge(&mut self, to: &mut Self::Data, from: Self::Data) -> DidMerge

Defines how to merge two Datas when their containing EClasses merge.

fn pre_union(
    egraph: &EGraph<L, Self>,
    id1: Id,
    id2: Id,
    justification: &Option<Justification>
)

An optional hook that allows inspection before a union occurs. When explanations are enabled, it gives two ids that represent the two particular terms being unioned, not the canonical ids for the two eclasses. It also gives a justification for the union when explanations are enabled.

fn modify(egraph: &mut EGraph<L, Self>, id: Id)

A hook that allows the modification of the EGraph.

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Display for Expr

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

Formats the value using the given formatter.

impl FromOp for Expr

type Error = FromOpError

The error type returned by from_op if its arguments do not represent a valid e-node.

fn from_op(op: &str, children: Vec<Id>) -> Result<Self, Self::Error>

Parse an e-node with operator op and children children.

impl Hash for Expr

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Language for Expr

fn matches(&self, other: &Self) -> bool

Returns true if this enode matches another enode. This should only consider the operator, not the children Ids.

fn children(&self) -> &[Id]

Returns the children of this e-node.

fn children_mut(&mut self) -> &mut [Id]

Returns a mutable slice of the children of this e-node.

fn for_each<F>(&self, f: F)where
    F: FnMut(Id),

Runs a given function on each child Id.

fn for_each_mut<F>(&mut self, f: F)where
    F: FnMut(&mut Id),

Runs a given function on each child Id, allowing mutation of that Id.

fn try_for_each<E, F>(&self, f: F) -> Result<(), E>where
    F: FnMut(Id) -> Result<(), E>,
    E: Clone,

Runs a falliable function on each child, stopping if the function returns an error.

fn len(&self) -> usize

Returns the number of the children this enode has.

fn is_leaf(&self) -> bool

Returns true if this enode has no children.

fn update_children<F>(&mut self, f: F)where
    F: FnMut(Id) -> Id,

Runs a given function to replace the children.

fn map_children<F>(self, f: F) -> Selfwhere
    F: FnMut(Id) -> Id,

Creates a new enode with children determined by the given function.

fn fold<F, T>(&self, init: T, f: F) -> Twhere
    F: FnMut(T, Id) -> T,
    T: Clone,

Folds over the children, given an initial accumulator.

fn all<F>(&self, f: F) -> boolwhere
    F: FnMut(Id) -> bool,

Returns true if the predicate is true on all children. Does not short circuit.

fn any<F>(&self, f: F) -> boolwhere
    F: FnMut(Id) -> bool,

Returns true if the predicate is true on any children. Does not short circuit.

fn join_recexprs<F, Expr>(&self, child_recexpr: F) -> RecExpr<Self>where
    F: FnMut(Id) -> Expr,
    Expr: AsRef<[Self]>,

Make a RecExpr by mapping this enodes children to other RecExprs.

fn build_recexpr<F>(&self, get_node: F) -> RecExpr<Self>where
    F: FnMut(Id) -> Self,

Build a RecExpr from an e-node.

fn try_build_recexpr<F, Err>(&self, get_node: F) -> Result<RecExpr<Self>, Err>where
    F: FnMut(Id) -> Result<Self, Err>,

Same as Language::build_recexpr, but fallible.

impl Ord for Expr

fn cmp(&self, other: &Expr) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Expr> for Expr

fn eq(&self, other: &Expr) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Expr> for Expr

fn partial_cmp(&self, other: &Expr) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Expr

impl StructuralEq for Expr

impl StructuralPartialEq for Expr