Enum HirRelationExpr

pub enum HirRelationExpr {
    Constant {
        rows: Vec<Row>,
        typ: SqlRelationType,
    },
    Get {
        id: Id,
        typ: SqlRelationType,
    },
    LetRec {
        limit: Option<LetRecLimit>,
        bindings: Vec<(String, LocalId, HirRelationExpr, SqlRelationType)>,
        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: HirScalarExpr,
        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: SqlRelationType

Get

Fields

id: Id

typ: SqlRelationType

LetRec

Mutually recursive CTE

Fields

limit: Option<LetRecLimit>

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

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

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

body: Box<HirRelationExpr>

Result of the AST node.

Let

CTE

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.

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

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

Fields

left: Box<HirRelationExpr>

right: Box<HirRelationExpr>

on: HirScalarExpr

kind: JoinKind

Reduce

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

Fields

input: Box<HirRelationExpr>

group_key: Vec<usize>

aggregates: Vec<AggregateExpr>

expected_group_size: Option<u64>

Distinct

Fields

input: Box<HirRelationExpr>

TopK

Groups and orders within each group, limiting output.

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. It is of SqlScalarType::Int64. (UInt64 would make sense in theory: Then we wouldn’t need to manually check non-negativity, but would just get this for free when casting to UInt64. However, Int64 is better for Postgres compat. This is because if there is a $1 here, then when external tools describe the prepared statement, they discover this type. If what they find were UInt64, then they might have trouble calling the prepared statement, because the unsigned types are non-standard, and also don’t exist even in Postgres.)

offset: HirScalarExpr

Number of records to skip. It is of SqlScalarType::Int64. This can contain parameters at first, but by the time we reach lowering, this should already be simply a Literal.

expected_group_size: Option<u64>

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

Negate

Fields

input: Box<HirRelationExpr>

Threshold

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

Fields

input: Box<HirRelationExpr>

Union

Fields

base: Box<HirRelationExpr>

inputs: Vec<HirRelationExpr>

Implementations

impl HirRelationExpr

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

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

impl<'a> HirRelationExpr

fn as_explain_single_plan( &'a mut self, context: &'a ExplainContext<'a>, ) -> Result<ExplainSinglePlan<'a, HirRelationExpr>, ExplainError>

impl HirRelationExpr

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

pub fn arity(&self) -> usize

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

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: HirScalarExpr, 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, scx: &StatementContext<'_>, lifetime: QueryLifetime, params: &Params, ) -> Result<(), PlanError>

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

pub fn contains_parameters(&self) -> Result<bool, PlanError>

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: SqlRelationType) -> Self

Constructs a constant collection from specific rows and schema.

pub fn finish_maintained( &mut self, finishing: &mut RowSetFinishing<HirScalarExpr, 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 trivial_row_set_finishing_hir( arity: usize, ) -> RowSetFinishing<HirScalarExpr, HirScalarExpr>

Returns a trivial finishing, i.e., that does nothing to the result set.

(There is also RowSetFinishing::trivial, but that is specialized for when the O generic parameter is not an HirScalarExpr anymore.)

pub fn is_trivial_row_set_finishing_hir( rsf: &RowSetFinishing<HirScalarExpr, HirScalarExpr>, arity: usize, ) -> bool

True if the finishing does nothing to any result set.

(There is also RowSetFinishing::is_trivial, but that is specialized for when the O generic parameter is not an HirScalarExpr anymore.)

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.

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

Whether the expression contains any UnmaterializableFunc call.

impl HirRelationExpr

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

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

fn applied_to( self, id_gen: &mut IdGen, get_outer: MirRelationExpr, col_map: &ColumnMap, cte_map: &mut BTreeMap<LocalId, CteDesc>, context: &Context<'_>, ) -> Result<MirRelationExpr, PlanError>

Return a MirRelationExpr which evaluates self once for each row of get_outer.

For uncorrelated self, this should be the cross-product between get_outer and self. When self references columns of get_outer, much more work needs to occur.

The col_map argument contains mappings to some of the columns of get_outer, though perhaps not all of them. It should be used as the basis of resolving column references, but care must be taken when adding new columns that get_outer.arity() is where they will start, rather than any function of col_map.

The get_outer expression should be a Get with no duplicate rows, describing the distinct assignment of values to outer rows.

Trait Implementations

impl Clone for HirRelationExpr

fn clone(&self) -> HirRelationExpr

Returns a duplicate 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,

Restrict a value to a certain interval.

impl PartialEq for HirRelationExpr

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

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