Struct mz_transform::typecheck::Typecheck

pub struct Typecheck {
    ctx: SharedContext,
    disallow_new_globals: bool,
    strict_join_equivalences: bool,
    recursion_guard: RecursionGuard,
}

Check that the visible type of each query has not been changed

Fields

ctx: SharedContext

The known types of the queries so far

disallow_new_globals: bool

Whether or not this is the first run of the transform

strict_join_equivalences: bool

Whether or not to be strict about join equivalences having the same nullability

recursion_guard: RecursionGuard

Recursion guard for checked recursion

Implementations

impl Typecheck

pub fn new(ctx: SharedContext) -> Self

Creates a typechecking consistency checking pass using a given shared context

pub fn disallow_new_globals(self) -> Self

New non-transient global IDs will be treated as an error

Only turn this on after the context has been appropraitely populated by, e.g., an earlier run

pub fn strict_join_equivalences(self) -> Self

Equivalence classes in joins must not only agree on scalar type, but also on nullability

Only turn this on before JoinImplementation

pub fn typecheck<'a>( &self, expr: &'a MirRelationExpr, ctx: &BTreeMap<Id, Vec<ColumnType>>, ) -> Result<Vec<ColumnType>, TypeError<'a>>

Returns the type of a relation expression or a type error.

This function is careful to check validity, not just find out the type.

It should be linear in the size of the AST.

??? should we also compute keys and return a RelationType? ggevay: Checking keys would have the same problem as checking nullability: key inference is very heuristic (even more so than nullability inference), so it’s almost impossible to reliably keep it stable across transformations.

fn collect_recursive_variable_types<'a>( &self, expr: &'a MirRelationExpr, ids: &[LocalId], ctx: &mut BTreeMap<Id, Vec<ColumnType>>, ) -> Result<(), TypeError<'a>>

Traverses a term to collect the types of given ids.

LetRec doesn’t have type info stored in it. Until we change the MIR to track that information explicitly, we have to rebuild it from looking at the term.

fn typecheck_scalar<'a>( &self, expr: &'a MirScalarExpr, source: &'a MirRelationExpr, column_types: &[ColumnType], ) -> Result<ColumnType, TypeError<'a>>

pub fn typecheck_aggregate<'a>( &self, expr: &'a AggregateExpr, source: &'a MirRelationExpr, column_types: &[ColumnType], ) -> Result<ColumnType, TypeError<'a>>

Typecheck an AggregateExpr

Trait Implementations

impl CheckedRecursion for Typecheck

fn recursion_guard(&self) -> &RecursionGuard

Extracts a reference to the recursion guard embedded within the type.

fn checked_recur<F, T, E>(&self, f: F) -> Result<T, E>

where F: FnOnce(&Self) -> Result<T, E>, E: From<RecursionLimitError>,

Checks whether it is safe to recur and calls f if so.

fn checked_recur_mut<F, T, E>(&mut self, f: F) -> Result<T, E>

where F: FnOnce(&mut Self) -> Result<T, E>, E: From<RecursionLimitError>,

Like CheckedRecursion::checked_recur, but operates on a mutable reference to Self.

impl Debug for Typecheck

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

Formats the value using the given formatter.

impl Transform for Typecheck

fn transform( &self, relation: &mut MirRelationExpr, transform_ctx: &mut TransformCtx<'_>, ) -> Result<(), TransformError>

Transform a relation into a functionally equivalent relation.

fn debug(&self) -> String

A string describing the transform.