Struct mz_adapter::optimize::dataflows::DataflowBuilder

pub struct DataflowBuilder<'a> {
    pub catalog: &'a CatalogState,
    pub compute: ComputeInstanceSnapshot,
    pub replan: Option<GlobalId>,
    enable_eager_delta_joins: bool,
    recursion_guard: RecursionGuard,
}

Borrows of catalog and indexes sufficient to build dataflow descriptions.

Fields

catalog: &'a CatalogState

compute: ComputeInstanceSnapshot

A handle to the compute abstraction, which describes indexes by identifier.

This can also be used to grab a handle to the storage abstraction, through its storage_mut() method.

replan: Option<GlobalId>

If set, indicates that the DataflowBuilder operates in “replan” mode and should consider only catalog items that are strictly less than the given GlobalId.

In particular, indexes with higher GlobalId that are present in the catalog will be ignored.

Bound from OptimizerConfig::replan.

enable_eager_delta_joins: bool

Bound from OptimizerConfig::enable_eager_delta_joins.

recursion_guard: RecursionGuard

A guard for recursive operations in this DataflowBuilder instance.

Implementations

impl DataflowBuilder<'_>

pub fn sufficient_collections<'a, I>(&self, ids: I) -> CollectionIdBundlewhere I: IntoIterator<Item = &'a GlobalId>,

Identifies a bundle of storage and compute collection ids sufficient for building a dataflow for the identifiers in ids out of the indexes available in this compute instance.

pub fn indexes_on( &self, id: GlobalId ) -> impl Iterator<Item = (GlobalId, &Index)>

impl<'a> DataflowBuilder<'a>

pub fn new(catalog: &'a CatalogState, compute: ComputeInstanceSnapshot) -> Self

pub(super) fn with_config(self, config: &OptimizerConfig) -> Self

pub fn import_into_dataflow( &mut self, id: &GlobalId, dataflow: &mut DataflowDesc ) -> Result<(), OptimizerError>

Imports the view, source, or table with id into the provided dataflow description.

pub fn import_view_into_dataflow( &mut self, view_id: &GlobalId, view: &OptimizedMirRelationExpr, dataflow: &mut DataflowDesc ) -> Result<(), OptimizerError>

Imports the view with the specified ID and expression into the provided dataflow description.

You should generally prefer calling DataflowBuilder::import_into_dataflow, which can handle objects of any type as long as they exist in the catalog. This method exists for when the view does not exist in the catalog, e.g., because it is identified by a GlobalId::Transient.

pub fn build_sink_dataflow( &mut self, name: String, id: GlobalId, sink_description: ComputeSinkDesc ) -> Result<(DataflowDesc, DataflowMetainfo), OptimizerError>

Builds a dataflow description for the sink with the specified name, ID, source, and output connection.

For as long as this dataflow is active, id can be used to reference the sink (primarily to drop it, at the moment).

pub fn build_sink_dataflow_into( &mut self, dataflow: &mut DataflowDesc, id: GlobalId, sink_description: ComputeSinkDesc ) -> Result<DataflowMetainfo, OptimizerError>

Like build_sink_dataflow, but builds the sink dataflow into the existing dataflow description instead of creating one from scratch.

pub fn reoptimize_imported_views( &self, df_desc: &mut DataflowDesc, config: &OptimizerConfig ) -> Result<(), OptimizerError>

fn monotonic_source(&self, source: &Source) -> bool

Determine the given source’s monotonicity.

fn monotonic_view(&self, id: GlobalId) -> bool

Determine the given view’s monotonicity.

This recursively traverses the expressions of all (materialized) views involved in the given view’s query expression. If this becomes a performance problem, we could add the monotonicity information of views into the catalog instead.

fn monotonic_view_inner( &self, id: GlobalId, memo: &mut BTreeMap<GlobalId, bool> ) -> Result<bool, RecursionLimitError>

Trait Implementations

impl<'a> CheckedRecursion for DataflowBuilder<'a>

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<'a> Debug for DataflowBuilder<'a>

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

Formats the value using the given formatter.

impl IndexOracle for DataflowBuilder<'_>

fn indexes_on( &self, id: GlobalId ) -> Box<dyn Iterator<Item = (GlobalId, &[MirScalarExpr])> + '_>

Returns an iterator over the indexes that exist on the identified collection.