Enum sql::plan::expr::HirRelationExpr

pub enum HirRelationExpr {
    Constant {
        rows: Vec<Row>,
        typ: RelationType,
    },
    Get {
        id: Id,
        typ: RelationType,
    },
    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>,
    },
    DeclareKeys {
        input: Box<HirRelationExpr>,
        keys: Vec<Vec<usize>>,
    },
}

Just like MirRelationExpr, except where otherwise noted below.

Variants

Constant

Fields

rows: Vec<Row>

typ: RelationType

Get

Fields

id: Id

typ: RelationType

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>

Union

Fields

base: Box<HirRelationExpr>

inputs: Vec<HirRelationExpr>

DeclareKeys

Fields

input: Box<HirRelationExpr>

keys: Vec<Vec<usize>>

Implementations

impl HirRelationExpr

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

pub fn arity(&self) -> usize

pub fn pretty(&self) -> String

Pretty-print this HirRelationExpr to a string.

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 declare_keys(self, keys: Vec<Vec<usize>>) -> 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), 

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

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

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

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

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

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

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

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

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

Like visit_columns, but permits mutating the column references.

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

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

Rewrite self into a 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 HashMap<LocalId, CteDesc>
) -> MirRelationExpr

Return a 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) -> MirRelationExpr

Perform optimizing algebraic rewrites on this HirRelationExpr and lower it to a 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 From<HirRelationExpr> for Model

fn from(expr: HirRelationExpr) -> Model

Performs the conversion.

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, 

Feeds a slice of this type into the given Hasher.

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: &HirRelationExpr) -> bool

This method tests for !=.

impl Eq for HirRelationExpr

impl StructuralEq for HirRelationExpr

impl StructuralPartialEq for HirRelationExpr