Enum mz_sql::plan::HirRelationExpr

pub enum HirRelationExpr {
    Constant {
        rows: Vec<Row>,
        typ: RelationType,
    },
    Get {
        id: Id,
        typ: RelationType,
    },
    LetRec {
        limit: Option<LetRecLimit>,
        bindings: Vec<(String, LocalId, HirRelationExpr, RelationType)>,
        body: Box<HirRelationExpr>,
    },
    Let {
        name: String,
        id: LocalId,
        value: Box<HirRelationExpr>,
        body: Box<HirRelationExpr>,
    },
    Project {
        input: Box<HirRelationExpr>,
        outputs: Vec<usize>,
    },
    Map {
        input: Box<HirRelationExpr>,
        scalars: Vec<HirScalarExpr>,
    },
    CallTable {
        func: TableFunc,
        exprs: Vec<HirScalarExpr>,
    },
    Filter {
        input: Box<HirRelationExpr>,
        predicates: Vec<HirScalarExpr>,
    },
    Join {
        left: Box<HirRelationExpr>,
        right: Box<HirRelationExpr>,
        on: HirScalarExpr,
        kind: JoinKind,
    },
    Reduce {
        input: Box<HirRelationExpr>,
        group_key: Vec<usize>,
        aggregates: Vec<AggregateExpr>,
        expected_group_size: Option<u64>,
    },
    Distinct {
        input: Box<HirRelationExpr>,
    },
    TopK {
        input: Box<HirRelationExpr>,
        group_key: Vec<usize>,
        order_key: Vec<ColumnOrder>,
        limit: Option<HirScalarExpr>,
        offset: usize,
        expected_group_size: Option<u64>,
    },
    Negate {
        input: Box<HirRelationExpr>,
    },
    Threshold {
        input: Box<HirRelationExpr>,
    },
    Union {
        base: Box<HirRelationExpr>,
        inputs: Vec<HirRelationExpr>,
    },
}

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

Variants

Constant

Fields

rows: Vec<Row>

typ: RelationType

Get

Fields

id: Id

typ: RelationType

LetRec

Fields

limit: Option<LetRecLimit>

Maximum number of iterations to evaluate. If None, then there is no limit.

bindings: Vec<(String, LocalId, HirRelationExpr, RelationType)>

List of bindings all of which are in scope of each other.

body: Box<HirRelationExpr>

Result of the AST node.

Mutually recursive CTE

Let

Fields

name: String

id: LocalId

The identifier to be used in Get variants to retrieve value.

value: Box<HirRelationExpr>

The collection to be bound to name.

body: Box<HirRelationExpr>

The result of the Let, evaluated with name bound to value.

CTE

Project

Fields

input: Box<HirRelationExpr>

outputs: Vec<usize>

Map

Fields

input: Box<HirRelationExpr>

scalars: Vec<HirScalarExpr>

CallTable

Fields

func: TableFunc

exprs: Vec<HirScalarExpr>

Filter

Fields

input: Box<HirRelationExpr>

predicates: Vec<HirScalarExpr>

Join

Fields

left: Box<HirRelationExpr>

right: Box<HirRelationExpr>

on: HirScalarExpr

kind: JoinKind

Unlike MirRelationExpr, we haven’t yet compiled LeftOuter/RightOuter/FullOuter joins away into more primitive exprs

Reduce

Fields

input: Box<HirRelationExpr>

group_key: Vec<usize>

aggregates: Vec<AggregateExpr>

expected_group_size: Option<u64>

Unlike MirRelationExpr, when key is empty AND input is empty this returns a single row with the aggregates evaluated over empty groups, rather than returning zero rows

Distinct

Fields

input: Box<HirRelationExpr>

TopK

Fields

input: Box<HirRelationExpr>

The source collection.

group_key: Vec<usize>

Column indices used to form groups.

order_key: Vec<ColumnOrder>

Column indices used to order rows within groups.

limit: Option<HirScalarExpr>

Number of records to retain

offset: usize

Number of records to skip

expected_group_size: Option<u64>

User-supplied hint: how many rows will have the same group key.

Groups and orders within each group, limiting output.

Negate

Fields

input: Box<HirRelationExpr>

Threshold

Fields

input: Box<HirRelationExpr>

Keep rows from a dataflow where the row counts are positive.

Union

Fields

base: Box<HirRelationExpr>

inputs: Vec<HirRelationExpr>

Implementations

impl HirRelationExpr

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

pub fn arity(&self) -> usize

pub fn as_const(&self) -> Option<(&Vec<Row>, &RelationType)>

If self is a constant, return the value and the type, otherwise None.

pub fn is_correlated(&self) -> bool

Reports whether this expression contains a column reference to its direct parent scope.

pub fn is_join_identity(&self) -> bool

pub fn project(self, outputs: Vec<usize>) -> Self

pub fn map(self, scalars: Vec<HirScalarExpr>) -> Self

pub fn filter(self, preds: Vec<HirScalarExpr>) -> Self

pub fn reduce( self, group_key: Vec<usize>, aggregates: Vec<AggregateExpr>, expected_group_size: Option<u64> ) -> Self

pub fn top_k( self, group_key: Vec<usize>, order_key: Vec<ColumnOrder>, limit: Option<HirScalarExpr>, offset: usize, expected_group_size: Option<u64> ) -> Self

pub fn negate(self) -> Self

pub fn distinct(self) -> Self

pub fn threshold(self) -> Self

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

pub fn exists(self) -> HirScalarExpr

pub fn select(self) -> HirScalarExpr

pub fn join( self, right: HirRelationExpr, on: HirScalarExpr, kind: JoinKind ) -> HirRelationExpr

pub fn take(&mut self) -> HirRelationExpr

pub fn visit<'a, F>(&'a self, depth: usize, f: &mut F)

where F: FnMut(&'a Self, usize),

👎Deprecated: Use Visit::visit_post.

pub fn visit_fallible<'a, F, E>( &'a self, depth: usize, f: &mut F ) -> Result<(), E>

where F: FnMut(&'a Self, usize) -> Result<(), E>,

👎Deprecated: Use Visit::try_visit_post.

pub fn visit1<'a, F, E>(&'a self, depth: usize, f: F) -> Result<(), E>

where F: FnMut(&'a Self, usize) -> Result<(), E>,

👎Deprecated: Use VisitChildren<HirRelationExpr>::try_visit_children instead.

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

where F: FnMut(&mut Self, usize),

👎Deprecated: Use Visit::visit_mut_post instead.

pub fn visit_mut_fallible<F, E>( &mut self, depth: usize, f: &mut F ) -> Result<(), E>

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

👎Deprecated: Use Visit::try_visit_mut_post instead.

pub fn visit1_mut<'a, F, E>(&'a mut self, depth: usize, f: F) -> Result<(), E>

where F: FnMut(&'a mut Self, usize) -> Result<(), E>,

👎Deprecated: Use VisitChildren<HirRelationExpr>::try_visit_mut_children instead.

pub fn visit_scalar_expressions<F, E>( &self, depth: usize, f: &mut F ) -> Result<(), E>

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

👎Deprecated: Use a combination of Visit and VisitChildren methods.

Visits all scalar expressions within the sub-tree of the given relation.

The depth argument should indicate the subquery nesting depth of the expression, which will be incremented when entering the RHS of a join or a subquery and presented to the supplied function f.

pub fn visit_scalar_expressions_mut<F, E>( &mut self, depth: usize, f: &mut F ) -> Result<(), E>

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

👎Deprecated: Use a combination of Visit and VisitChildren methods.

Like visit_scalar_expressions, but permits mutating the expressions.

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 relation expression.

The depth argument should indicate the subquery nesting depth of the expression, which will be incremented when entering the RHS of a join or a subquery 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 bind_parameters(&mut self, params: &Params) -> Result<(), PlanError>

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

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

See the documentation for HirScalarExpr::splice_parameters.

pub fn constant(rows: Vec<Vec<Datum<'_>>>, typ: RelationType) -> Self

Constructs a constant collection from specific rows and schema.

pub fn finish_maintained( &mut self, finishing: &mut RowSetFinishing<HirScalarExpr>, group_size_hints: GroupSizeHints )

A RowSetFinishing can only be directly applied to the result of a one-shot select. This function is concerned with maintained queries, e.g., an index or materialized view. Instead of directly applying the given RowSetFinishing, it converts the RowSetFinishing to a TopK, which it then places at the top of self. Additionally, it turns the given finishing into a trivial finishing.

pub fn could_run_expensive_function(&self) -> bool

The HirRelationExpr is considered potentially expensive if and only if at least one of the following conditions is true:

• It contains at least one CallTable or a Reduce operator.
• It contains at least one HirScalarExpr with a function call.

!!!WARNING!!!: this method has an MirRelationExpr counterpart. The two should be kept in sync w.r.t. HIR ⇒ MIR lowering!

pub fn contains_temporal(&self) -> Result<bool, RecursionLimitError>

Whether the expression contains an UnmaterializableFunc::MzNow call.

impl HirRelationExpr

pub fn lower<C: Into<Config>>( self, config: C ) -> Result<MirRelationExpr, PlanError>

Rewrite self into a MirRelationExpr. This requires rewriting all correlated subqueries (nested HirRelationExprs) into flat queries

Trait Implementations

impl Clone for HirRelationExpr

fn clone(&self) -> HirRelationExpr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CollectionPlan for HirRelationExpr

fn depends_on_into(&self, out: &mut BTreeSet<GlobalId>)

Collects the set of global identifiers from dataflows referenced in Get.

fn depends_on(&self) -> BTreeSet<GlobalId>

Returns the set of global identifiers from dataflows referenced in Get.

impl Debug for HirRelationExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HirRelationExpr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl DisplayText<PlanRenderingContext<'_, HirRelationExpr>> for HirRelationExpr

fn fmt_text( &self, f: &mut Formatter<'_>, ctx: &mut PlanRenderingContext<'_, HirRelationExpr> ) -> Result

impl<'a> Explain<'a> for HirRelationExpr

type Context = ExplainContext<'a>

The type of the immutable context in which the explanation will be rendered.

type Text = ExplainSinglePlan<'a, HirRelationExpr>

The explanation type produced by a successful Explain::explain_text call.

type Json = ExplainSinglePlan<'a, HirRelationExpr>

The explanation type produced by a successful Explain::explain_json call.

type Dot = UnsupportedFormat

The explanation type produced by a successful Explain::explain_json call.

fn explain_text( &'a mut self, context: &'a Self::Context ) -> Result<Self::Text, ExplainError>

Construct a Result::Ok of the Explain::Text format from the config and the context.

fn explain_json( &'a mut self, context: &'a Self::Context ) -> Result<Self::Json, ExplainError>

Construct a Result::Ok of the Explain::Json format from the config and the context.

fn explain( &'a mut self, format: &'a ExplainFormat, context: &'a Self::Context ) -> Result<String, ExplainError>

Explain an instance of Self within the given Explain::Context.

fn explain_dot( &'a mut self, context: &'a Self::Context ) -> Result<Self::Dot, ExplainError>

Construct a Result::Ok of the Explain::Dot format from the config and the context.

impl Hash for HirRelationExpr

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 HirRelationExpr

fn cmp(&self, other: &HirRelationExpr) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for HirRelationExpr

fn eq(&self, other: &HirRelationExpr) -> 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 for HirRelationExpr

fn partial_cmp(&self, other: &HirRelationExpr) -> 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 Serialize for HirRelationExpr

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl VisitChildren<HirRelationExpr> for HirRelationExpr

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 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 Eq for HirRelationExpr

impl StructuralPartialEq for HirRelationExpr