Enum HirScalarExpr

pub enum HirScalarExpr {
    Column(ColumnRef, TreatAsEqual<Option<Arc<str>>>),
    Parameter(usize, TreatAsEqual<Option<Arc<str>>>),
    Literal(Row, SqlColumnType, TreatAsEqual<Option<Arc<str>>>),
    CallUnmaterializable(UnmaterializableFunc, TreatAsEqual<Option<Arc<str>>>),
    CallUnary {
        func: UnaryFunc,
        expr: Box<HirScalarExpr>,
        name: TreatAsEqual<Option<Arc<str>>>,
    },
    CallBinary {
        func: BinaryFunc,
        expr1: Box<HirScalarExpr>,
        expr2: Box<HirScalarExpr>,
        name: TreatAsEqual<Option<Arc<str>>>,
    },
    CallVariadic {
        func: VariadicFunc,
        exprs: Vec<HirScalarExpr>,
        name: TreatAsEqual<Option<Arc<str>>>,
    },
    If {
        cond: Box<HirScalarExpr>,
        then: Box<HirScalarExpr>,
        els: Box<HirScalarExpr>,
        name: TreatAsEqual<Option<Arc<str>>>,
    },
    Exists(Box<HirRelationExpr>, TreatAsEqual<Option<Arc<str>>>),
    Select(Box<HirRelationExpr>, TreatAsEqual<Option<Arc<str>>>),
    Windowing(WindowExpr, TreatAsEqual<Option<Arc<str>>>),
}

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

Variants

Column(ColumnRef, TreatAsEqual<Option<Arc<str>>>)

Unlike mz_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, TreatAsEqual<Option<Arc<str>>>)

Literal(Row, SqlColumnType, TreatAsEqual<Option<Arc<str>>>)

CallUnmaterializable(UnmaterializableFunc, TreatAsEqual<Option<Arc<str>>>)

CallUnary

Fields

func: UnaryFunc

expr: Box<HirScalarExpr>

name: TreatAsEqual<Option<Arc<str>>>

CallBinary

Fields

func: BinaryFunc

expr1: Box<HirScalarExpr>

expr2: Box<HirScalarExpr>

name: TreatAsEqual<Option<Arc<str>>>

CallVariadic

Fields

func: VariadicFunc

exprs: Vec<HirScalarExpr>

name: TreatAsEqual<Option<Arc<str>>>

If

Fields

cond: Box<HirScalarExpr>

then: Box<HirScalarExpr>

els: Box<HirScalarExpr>

name: TreatAsEqual<Option<Arc<str>>>

Exists(Box<HirRelationExpr>, TreatAsEqual<Option<Arc<str>>>)

Returns true if expr returns any rows

Select(Box<HirRelationExpr>, TreatAsEqual<Option<Arc<str>>>)

Given expr with arity 1. If expr returns:

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

• 1 rows, we return an error

Windowing(WindowExpr, TreatAsEqual<Option<Arc<str>>>)

Implementations

impl HirScalarExpr

pub fn name(&self) -> Option<Arc<str>>

pub fn bind_parameters( &mut self, scx: &StatementContext<'_>, lifetime: QueryLifetime, params: &Params, ) -> Result<(), PlanError>

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 contains_temporal(&self) -> bool

Whether the expression contains an UnmaterializableFunc::MzNow call.

pub fn contains_unmaterializable(&self) -> bool

Whether the expression contains any UnmaterializableFunc call.

pub fn column(index: usize) -> HirScalarExpr

Constructs an unnamed column reference in the current scope. Use HirScalarExpr::named_column when a name is known. Use HirScalarExpr::unnamed_column for a ColumnRef.

pub fn unnamed_column(cr: ColumnRef) -> HirScalarExpr

Constructs an unnamed column reference.

pub fn named_column(cr: ColumnRef, name: Arc<str>) -> HirScalarExpr

Constructs a named column reference. Names are interned by a NameManager.

pub fn parameter(n: usize) -> HirScalarExpr

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

pub fn literal_true() -> HirScalarExpr

pub fn literal_false() -> HirScalarExpr

pub fn literal_null(scalar_type: SqlScalarType) -> HirScalarExpr

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

pub fn as_literal(&self) -> Option<Datum<'_>>

pub fn is_literal_true(&self) -> bool

pub fn is_literal_false(&self) -> bool

pub fn is_literal_null(&self) -> bool

pub fn is_constant(&self) -> bool

Return true iff self consists only of literals, materializable function calls, and if-else statements.

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

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

pub fn call_unmaterializable(func: UnmaterializableFunc) -> Self

pub fn call_variadic(func: VariadicFunc, exprs: Vec<Self>) -> Self

pub fn if_then_else(cond: Self, then: Self, els: Self) -> Self

pub fn windowing(expr: WindowExpr) -> Self

pub fn or(self, other: Self) -> Self

pub fn and(self, other: Self) -> Self

pub fn not(self) -> Self

pub fn call_is_null(self) -> Self

pub fn variadic_and(args: Vec<HirScalarExpr>) -> HirScalarExpr

Calls AND with the given arguments. Simplifies if 0 or 1 args.

pub fn variadic_or(args: Vec<HirScalarExpr>) -> HirScalarExpr

Calls OR with the given arguments. Simplifies if 0 or 1 args.

pub fn take(&mut self) -> Self

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

where F: FnMut(usize, &ColumnRef),

👎Deprecated: Redefine this based on the Visit and VisitChildren methods.

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),

👎Deprecated: Redefine this based on the Visit and VisitChildren methods.

Like visit_columns, but permits mutating the column references.

pub fn visit_columns_referring_to_root_level<F>(&self, f: &mut F)

where F: FnMut(usize),

Visits those column references in this scalar expression that refer to the root level. These include column references that are at the root level, as well as column references that are at a deeper subquery nesting depth, but refer back to the root level. (Note that even if self is embedded inside a larger expression, we consider the “root level” to be self’s level.)

pub fn visit_columns_referring_to_root_level_mut<F>(&mut self, f: &mut F)

where F: FnMut(&mut usize),

Like visit_columns_referring_to_root_level, 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>,

👎Deprecated: Redefine this based on the Visit and VisitChildren methods.

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>,

👎Deprecated: Redefine this based on the Visit and VisitChildren methods.

Like visit_recursively, but permits mutating the scalar expressions.

fn simplify_to_literal(self) -> Option<Row>

Attempts to simplify self into a literal.

Returns None if self is not constant and therefore can’t be simplified to a literal, or if an evaluation error occurs during simplification, or if self contains

• a subquery
• a column reference to an outer level
• a parameter
• a window function call

fn simplify_to_literal_with_result(self) -> Result<Row, PlanError>

Simplifies self into a literal. If this is not possible (e.g., because self is not constant or an evaluation error occurs during simplification), it returns PlanError::ConstantExpressionSimplificationFailed.

The returned error is an internal error if the expression contains

• a subquery
• a column reference to an outer level
• a parameter
• a window function call

TODO: use this everywhere instead of simplify_to_literal, so that we don’t hide the error msg.

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 SqlScalarType::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 SqlScalarType::String.

pub fn into_literal_mz_timestamp(self) -> Option<Timestamp>

Attempts to simplify this expression to a literal MzTimestamp.

Returns None if the expression simplifies to null or if the expression cannot be simplified, e.g. because it contains non-literal values or a cast fails.

TODO: Make this (and the other similar fns above) return Result, so that we can show the error when it fails. (E.g., there can be non-trivial cast errors.) See try_into_literal_int64 as an example.

Panics

Panics if this expression does not have type SqlScalarType::MzTimestamp.

pub fn try_into_literal_int64(self) -> Result<i64, PlanError>

Attempts to simplify this expression of SqlScalarType::Int64 to a literal Int64 and returns it as an i64.

Returns PlanError::ConstantExpressionSimplificationFailed if

• it’s not a constant expression (as determined by is_constant)
• evaluates to null
• an EvalError occurs during evaluation (e.g., a cast fails)

Panics

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

pub fn contains_parameters(&self) -> bool

impl HirScalarExpr

fn applied_to( self, id_gen: &mut IdGen, col_map: &ColumnMap, cte_map: &mut BTreeMap<LocalId, CteDesc>, inner: &mut MirRelationExpr, subquery_map: &Option<&BTreeMap<HirScalarExpr, usize>>, context: &Context<'_>, ) -> Result<MirScalarExpr, PlanError>

Rewrite self into a mz_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 window_func_applied_to<F>( id_gen: &mut IdGen, col_map: &ColumnMap, cte_map: &mut BTreeMap<LocalId, CteDesc>, inner: &mut MirRelationExpr, subquery_map: &Option<&BTreeMap<HirScalarExpr, usize>>, partition_by: Vec<HirScalarExpr>, order_by: Vec<HirScalarExpr>, mir_aggr_func: AggregateFunc, lower_args: F, context: &Context<'_>, ) -> Result<MirScalarExpr, PlanError>

where F: FnOnce(&mut IdGen, &ColumnMap, &mut BTreeMap<LocalId, CteDesc>, &mut MirRelationExpr, &Option<&BTreeMap<HirScalarExpr, usize>>, Vec<MirScalarExpr>, MirScalarExpr, SqlScalarType) -> Result<(MirScalarExpr, SqlColumnType), PlanError>,

fn lower_subqueries( exprs: &[Self], id_gen: &mut IdGen, col_map: &ColumnMap, cte_map: &mut BTreeMap<LocalId, CteDesc>, inner: MirRelationExpr, context: &Context<'_>, ) -> Result<(MirRelationExpr, BTreeMap<HirScalarExpr, usize>), PlanError>

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, PlanError>

Rewrites self into a mz_expr::ScalarExpr.

Returns an internal error if the expression contains

• a subquery
• a column reference to an outer level
• a parameter
• a window function call

Should succeed if HirScalarExpr::is_constant would return true on self.

impl HirScalarExpr

fn support(&self) -> Vec<usize>

Similar to MirScalarExpr::support, but adapted to HirScalarExpr in a special way: it considers column references that target the root level. (See visit_columns_referring_to_root_level.)

fn remap(self, idx_map: &BTreeMap<usize, usize>) -> HirScalarExpr

Changes column references in self by the given remapping. Panics if a referred column is not present in idx_map!

Trait Implementations

impl AbstractExpr for HirScalarExpr

type Type = SqlColumnType

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

Computes the type of the expression.

impl Clone for HirScalarExpr

fn clone(&self) -> HirScalarExpr

Returns a duplicate 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<'de> Deserialize<'de> for HirScalarExpr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display 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

Converts to this type from the input type.

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for HirScalarExpr

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for HirScalarExpr

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for HirScalarExpr

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl ScalarOps for HirScalarExpr

fn match_col_ref(&self) -> Option<usize>

fn references(&self, column: usize) -> bool

impl Serialize for HirScalarExpr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl VisitChildren<HirScalarExpr> for AggregateWindowExpr

fn visit_children<F>(&self, f: F)

where F: FnMut(&HirScalarExpr),

Apply an infallible immutable function f to each direct child.

fn visit_mut_children<F>(&mut self, f: F)

where F: FnMut(&mut HirScalarExpr),

Apply an infallible mutable function f to each direct child.

fn try_visit_children<F, E>(&self, f: F) -> Result<(), E>

where F: FnMut(&HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible immutable function f to each direct child.

fn try_visit_mut_children<F, E>(&mut self, f: F) -> Result<(), E>

where F: FnMut(&mut HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible mutable function f to each direct child.

impl VisitChildren<HirScalarExpr> for HirRelationExpr

fn visit_children<F>(&self, f: F)

where F: FnMut(&HirScalarExpr),

Apply an infallible immutable function f to each direct child.

fn visit_mut_children<F>(&mut self, f: F)

where F: FnMut(&mut HirScalarExpr),

Apply an infallible mutable function f to each direct child.

fn try_visit_children<F, E>(&self, f: F) -> Result<(), E>

where F: FnMut(&HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible immutable function f to each direct child.

fn try_visit_mut_children<F, E>(&mut self, f: F) -> Result<(), E>

where F: FnMut(&mut HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible mutable function f to each direct child.

impl VisitChildren<HirScalarExpr> for HirScalarExpr

fn visit_children<F>(&self, f: F)

where F: FnMut(&Self),

Apply an infallible immutable function f to each direct child.

fn visit_mut_children<F>(&mut self, f: F)

where F: FnMut(&mut Self),

Apply an infallible mutable function f to each direct child.

fn try_visit_children<F, E>(&self, f: F) -> Result<(), E>

where F: FnMut(&Self) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible immutable function f to each direct child.

fn try_visit_mut_children<F, E>(&mut self, f: F) -> Result<(), E>

where F: FnMut(&mut Self) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible mutable function f to each direct child.

impl VisitChildren<HirScalarExpr> for ValueWindowExpr

fn visit_children<F>(&self, f: F)

where F: FnMut(&HirScalarExpr),

Apply an infallible immutable function f to each direct child.

fn visit_mut_children<F>(&mut self, f: F)

where F: FnMut(&mut HirScalarExpr),

Apply an infallible mutable function f to each direct child.

fn try_visit_children<F, E>(&self, f: F) -> Result<(), E>

where F: FnMut(&HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible immutable function f to each direct child.

fn try_visit_mut_children<F, E>(&mut self, f: F) -> Result<(), E>

where F: FnMut(&mut HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible mutable function f to each direct child.

impl VisitChildren<HirScalarExpr> for WindowExpr

fn visit_children<F>(&self, f: F)

where F: FnMut(&HirScalarExpr),

Apply an infallible immutable function f to each direct child.

fn visit_mut_children<F>(&mut self, f: F)

where F: FnMut(&mut HirScalarExpr),

Apply an infallible mutable function f to each direct child.

fn try_visit_children<F, E>(&self, f: F) -> Result<(), E>

where F: FnMut(&HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible immutable function f to each direct child.

fn try_visit_mut_children<F, E>(&mut self, f: F) -> Result<(), E>

where F: FnMut(&mut HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible mutable function f to each direct child.

impl VisitChildren<HirScalarExpr> for WindowExprType

fn visit_children<F>(&self, f: F)

where F: FnMut(&HirScalarExpr),

Apply an infallible immutable function f to each direct child.

fn visit_mut_children<F>(&mut self, f: F)

where F: FnMut(&mut HirScalarExpr),

Apply an infallible mutable function f to each direct child.

fn try_visit_children<F, E>(&self, f: F) -> Result<(), E>

where F: FnMut(&HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible immutable function f to each direct child.

fn try_visit_mut_children<F, E>(&mut self, f: F) -> Result<(), E>

where F: FnMut(&mut HirScalarExpr) -> Result<(), E>, E: From<RecursionLimitError>,

Apply a fallible mutable function f to each direct child.

impl Eq for HirScalarExpr

impl StructuralPartialEq for HirScalarExpr