Enum sql::plan::HirScalarExpr

pub enum HirScalarExpr {
    Column(ColumnRef),
    Parameter(usize),
    Literal(Row, ColumnType),
    CallNullary(NullaryFunc),
    CallUnary {
        func: UnaryFunc,
        expr: Box<HirScalarExpr>,
    },
    CallBinary {
        func: BinaryFunc,
        expr1: Box<HirScalarExpr>,
        expr2: Box<HirScalarExpr>,
    },
    CallVariadic {
        func: VariadicFunc,
        exprs: Vec<HirScalarExpr>,
    },
    If {
        cond: Box<HirScalarExpr>,
        then: Box<HirScalarExpr>,
        els: Box<HirScalarExpr>,
    },
    Exists(Box<HirRelationExpr>),
    Select(Box<HirRelationExpr>),
    Windowing(WindowExpr),
}

Just like expr::MirScalarExpr, except where otherwise noted below.

Variants

Column(ColumnRef)

Tuple Fields

0: ColumnRef

Unlike expr::MirScalarExpr, we can nest HirRelationExprs via eg Exists. This means that a variable could refer to a column of the current input, or to a column of an outer relation. We use ColumnRef to denote the difference.

Parameter(usize)

Tuple Fields

0: usize

Literal(Row, ColumnType)

Tuple Fields

0: Row

1: ColumnType

CallNullary(NullaryFunc)

Tuple Fields

0: NullaryFunc

CallUnary

Fields

func: UnaryFunc

expr: Box<HirScalarExpr>

CallBinary

Fields

func: BinaryFunc

expr1: Box<HirScalarExpr>

expr2: Box<HirScalarExpr>

CallVariadic

Fields

func: VariadicFunc

exprs: Vec<HirScalarExpr>

If

Fields

cond: Box<HirScalarExpr>

then: Box<HirScalarExpr>

els: Box<HirScalarExpr>

Exists(Box<HirRelationExpr>)

Tuple Fields

0: Box<HirRelationExpr>

Returns true if expr returns any rows

Select(Box<HirRelationExpr>)

Tuple Fields

0: Box<HirRelationExpr>

Given expr with arity 1. If expr returns:

• 0 rows, return NULL
• 1 row, return the value of that row

• 1 rows, the sql spec says we should throw an error but we can’t (see https://github.com/MaterializeInc/materialize/issues/489) so instead we return all the rows. If there are multiple Select expressions in a single SQL query, the result is that we take the product of all of them. This is counter to the spec, but is consistent with eg postgres’ treatment of multiple set-returning-functions (see https://tapoueh.org/blog/2017/10/set-returning-functions-and-postgresql-10/).

Windowing(WindowExpr)

Tuple Fields

0: WindowExpr

Implementations

impl HirScalarExpr

pub fn bind_parameters(&mut self, params: &Params) -> Result<(), Error>

Replaces any parameter references in the expression with the corresponding datum in params.

pub fn splice_parameters(&mut self, params: &[HirScalarExpr], depth: usize)

Like HirScalarExpr::bind_parameters, except that parameters are replaced with the corresponding expression fragment from params rather than a datum.

Specifically, the parameter $1 will be replaced with params[0], the parameter $2 will be replaced with params[1], and so on. Parameters in self that refer to invalid indices of params will cause a panic.

Column references in parameters will be corrected to account for the depth at which they are spliced.

pub fn column(index: usize) -> HirScalarExpr

Constructs a column reference in the current scope.

pub fn literal(datum: Datum<'_>, scalar_type: ScalarType) -> HirScalarExpr

pub fn literal_true() -> HirScalarExpr

pub fn literal_null(scalar_type: ScalarType) -> HirScalarExpr

pub fn literal_1d_array(
    datums: Vec<Datum<'_>>,
    element_scalar_type: ScalarType
) -> Result<HirScalarExpr, Error>

pub fn call_unary(self, func: UnaryFunc) -> Self

pub fn call_binary(self, other: Self, func: BinaryFunc) -> Self

pub fn take(&mut self) -> Self

pub fn visit<'a, F>(&'a self, f: &mut F) where
    F: FnMut(&'a Self), 

pub fn visit1<'a, F>(&'a self, f: F) where
    F: FnMut(&'a Self), 

pub fn visit_mut<F>(&mut self, f: &mut F) where
    F: FnMut(&mut Self), 

pub fn visit_mut_pre<F>(&mut self, f: &mut F) where
    F: FnMut(&mut Self), 

pub fn visit1_mut<F>(&mut self, f: F) where
    F: FnMut(&mut Self), 

pub fn visit_pre_post<F1, F2>(&self, pre: &mut F1, post: &mut F2) where
    F1: FnMut(&Self) -> Option<Vec<&Self>>,
    F2: FnMut(&Self), 

A generalization of visit. The function pre runs on a HirScalarExpr before it runs on any of the child HirScalarExprs. The function post runs on child HirScalarExprs first before the parent. Optionally, pre can return which child HirScalarExprs, if any, should be visited (default is to visit all children).

pub fn visit_columns<F>(&self, depth: usize, f: &mut F) where
    F: FnMut(usize, &ColumnRef), 

Visits the column references in this scalar expression.

The depth argument should indicate the subquery nesting depth of the expression, which will be incremented with each subquery entered and presented to the supplied function f.

pub fn visit_columns_mut<F>(&mut self, depth: usize, f: &mut F) where
    F: FnMut(usize, &mut ColumnRef), 

Like visit_columns, but permits mutating the column references.

pub fn visit_recursively<F, E>(&self, depth: usize, f: &mut F) -> Result<(), E> where
    F: FnMut(usize, &HirScalarExpr) -> Result<(), E>, 

Like visit but it enters the subqueries visiting the scalar expressions contained in them. It takes the current depth of the expression and increases it when entering a subquery.

pub fn visit_recursively_mut<F, E>(
    &mut self,
    depth: usize,
    f: &mut F
) -> Result<(), E> where
    F: FnMut(usize, &mut HirScalarExpr) -> Result<(), E>, 

Like visit_recursively, but permits mutating the scalar expressions.

fn simplify_to_literal(self) -> Option<Row>

pub fn into_literal_int64(self) -> Option<i64>

Attempts to simplify this expression to a literal 64-bit integer.

Returns None if this expression cannot be simplified, e.g. because it contains non-literal values.

Panics

Panics if this expression does not have type ScalarType::Int64.

pub fn into_literal_string(self) -> Option<String>

Attempts to simplify this expression to a literal string.

Returns None if this expression cannot be simplified, e.g. because it contains non-literal values.

Panics

Panics if this expression does not have type ScalarType::String.

impl HirScalarExpr

fn applied_to(
    self,
    id_gen: &mut IdGen,
    col_map: &ColumnMap,
    cte_map: &mut HashMap<LocalId, CteDesc>,
    inner: &mut MirRelationExpr,
    subquery_map: &Option<&HashMap<HirScalarExpr, usize>>
) -> MirScalarExpr

Rewrite self into a expr::ScalarExpr which can be applied to the modified inner.

This method is responsible for decorrelating subqueries in self by introducing further columns to inner, and rewriting self to refer to its physical columns (specified by usize positions). The most complicated logic is for the scalar expressions that involve subqueries, each of which are documented in more detail closer to their logic.

This process presumes that inner is the result of decorrelation, meaning its first several columns may be inherited from outer relations. The col_map column map should provide specific offsets where each of these references can be found.

fn lower_subqueries(
    exprs: &[Self],
    id_gen: &mut IdGen,
    col_map: &ColumnMap,
    cte_map: &mut HashMap<LocalId, CteDesc>,
    inner: MirRelationExpr
) -> (MirRelationExpr, HashMap<HirScalarExpr, usize>)

Applies the subqueries in the given list of scalar expressions to every distinct value of the given relation and returns a join of the given relation with all the subqueries found, and the mapping of scalar expressions with columns projected by the returned join that will hold their results.

pub fn lower_uncorrelated(self) -> Result<MirScalarExpr, Error>

Rewrites self into a expr::ScalarExpr.

Trait Implementations

impl AbstractExpr for HirScalarExpr

type Type = ColumnType

fn typ(
    &self,
    outers: &[RelationType],
    inner: &RelationType,
    params: &BTreeMap<usize, ScalarType>
) -> Self::Type

Computes the type of the expression.

impl Clone for HirScalarExpr

fn clone(&self) -> HirScalarExpr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HirScalarExpr

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

Formats the value using the given formatter.

impl From<HirScalarExpr> for CoercibleScalarExpr

fn from(expr: HirScalarExpr) -> CoercibleScalarExpr

Performs the conversion.

impl GetReturnType for HirScalarExpr

fn return_type(
    &self,
    ecx: &ExprContext<'_>,
    param_list: &ParamList
) -> ReturnType

impl Hash for HirScalarExpr

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, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<HirScalarExpr> for HirScalarExpr

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

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

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

This method tests for !=.

impl Eq for HirScalarExpr

impl StructuralEq for HirScalarExpr

impl StructuralPartialEq for HirScalarExpr