Enum mz_sql::plan::expr::HirRelationExpr

pub enum HirRelationExpr {
    Constant {
        rows: Vec<Row>,
        typ: RelationType,
    },
    Get {
        id: Id,
        typ: RelationType,
    },
    LetRec {
        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<usize>,
    },
    Distinct {
        input: Box<HirRelationExpr>,
    },
    TopK {
        input: Box<HirRelationExpr>,
        group_key: Vec<usize>,
        order_key: Vec<ColumnOrder>,
        limit: Option<usize>,
        offset: usize,
    },
    Negate {
        input: Box<HirRelationExpr>,
    },
    Threshold {
        input: Box<HirRelationExpr>,
    },
    Union {
        base: Box<HirRelationExpr>,
        inputs: Vec<HirRelationExpr>,
    },
}

Just like MirRelationExpr, except where otherwise noted below.

Variants

Constant

Fields

rows: Vec<Row>

typ: RelationType

Get

Fields

id: Id

typ: RelationType

LetRec

Fields

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

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

Number of records to retain

offset: usize

Number of records to skip

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

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: &[RelationType],
    params: &BTreeMap<usize, ScalarType>
) -> RelationType

pub fn arity(&self) -> usize

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, predicates: Vec<HirScalarExpr>) -> Self

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

pub fn top_k(
    self,
    group_key: Vec<usize>,
    order_key: Vec<ColumnOrder>,
    limit: Option<usize>,
    offset: usize
) -> 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(&mut self, finishing: RowSetFinishing)

impl HirRelationExpr

pub fn lower(self) -> Result<MirRelationExpr, PlanError>

Rewrite self into a mz_expr::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>
) -> Result<MirRelationExpr, PlanError>

Return a mz_expr::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.

impl HirRelationExpr

pub fn optimize_and_lower(
    self,
    _config: &OptimizerConfig
) -> Result<MirRelationExpr, PlanError>

Perform optimizing algebraic rewrites on this HirRelationExpr and lower it to a mz_expr::MirRelationExpr.

The optimization path is fully-determined by the values of the feature flag defined in the OptimizerConfig.

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 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) -> 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<HirRelationExpr> 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<HirRelationExpr> 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 StructuralEq for HirRelationExpr

impl StructuralPartialEq for HirRelationExpr