Struct mz_sql::query_model::mir::Lowerer

struct Lowerer<'a> {
    model: &'a Model,
    id_gen: IdGen,
    lets: Vec<(LocalId, MirRelationExpr)>,
    common_boxes: HashMap<BoxId, usize>,
}

Fields

model: &'a Model

id_gen: IdGen

Generates mz_expr::LocalId as an alias for common expressions.

lets: Vec<(LocalId, MirRelationExpr)>

Stack of common expressions that have been given a mz_expr::LocalId.

common_boxes: HashMap<BoxId, usize>

Map of (BoxIds whose MIR representation has been given a mz_expr::LocalId) -> (position of its MIR representation in lets)

Implementations

impl<'a> Lowerer<'a>

fn new(model: &'a Model) -> Self

fn push_let(&mut self, rel: MirRelationExpr) -> (MirRelationExpr, Option<usize>)

Pushes a relation to the stack of common expressions.

If rel is a mz_expr::MirRelationExpr::Get, it does not get added to the stack.

Returns

• the mz_expr::MirRelationExpr that will retrieve the common expression.
• the location of rel, if any, within self.lets.

fn lower(&mut self) -> Result<MirRelationExpr, QGMError>

Converts self.model to a mz_expr::MirRelationExpr.

fn apply(
    &mut self,
    box_id: BoxId,
    get_outer: MirRelationExpr,
    outer_column_map: &HashMap<ColumnReference, usize>
) -> Result<MirRelationExpr, QGMError>

Applies the given box identified by its ID to the given outer relation.

fn lower_join(
    &mut self,
    get_outer: MirRelationExpr,
    outer_column_map: &HashMap<ColumnReference, usize>,
    quantifiers: &BTreeSet<QuantifierId>
) -> Result<(MirRelationExpr, HashMap<ColumnReference, usize>), QGMError>

Generates a join among the result of applying the outer relation to the given quantifiers. Returns a relation and a map of column references that can be used to lower expressions that sit directly on top of the join.

The quantifiers are joined on the columns of the outer relation. TODO(asenac) Since decorrelation is not yet supported the outer relation is currently always the join identity, so the result of this method is always a cross-join of the given quantifiers, which makes part of this code untesteable at the moment.

fn lower_join_inner(
    &mut self,
    outer_column_map: &HashMap<ColumnReference, usize>,
    outer_arity: usize,
    inputs: Vec<(QuantifierId, MirRelationExpr)>
) -> (MirRelationExpr, HashMap<ColumnReference, usize>)

Same as lower_join except the outer relation has already been applied to the quantifiers.

fn lower_quantifier(
    &mut self,
    quantifier_id: QuantifierId,
    get_outer: MirRelationExpr,
    outer_column_map: &HashMap<ColumnReference, usize>
) -> Result<MirRelationExpr, QGMError>

Lowers the given quantifier by applying it to the outer relation.

fn lower_box_columns(
    rel: MirRelationExpr,
    the_box: &BoundRef<'_, QueryBox>,
    column_map: &HashMap<ColumnReference, usize>,
    outer_arity: usize,
    input_arity: usize
) -> Result<MirRelationExpr, QGMError>

fn join_on_prefix(
    join_inputs: Vec<MirRelationExpr>,
    prefix_length: usize
) -> (MirRelationExpr, JoinInputMapper)

Join the given inputs on a shared common prefix.

TODO(asenac) Given the lack of support for decorrelation at the moment, this method is always called with prefix_length 0, and hence, it remains untested.

fn lower_expression(
    expr: &BoxScalarExpr,
    column_map: &HashMap<ColumnReference, usize>
) -> Result<MirScalarExpr, QGMError>

Lowers a scalar expression, resolving the column references using the supplied column map.