pub fn from_mir(
        expr: &MirRelationExpr,
        arrangements: &mut BTreeMap<Id, Vec<Vec<MirScalarExpr>>>,
    ) -> Result<(Self, Vec<Vec<MirScalarExpr>>), ()> {
        // This function is recursive and can overflow its stack, so grow it if
        // needed. The growth here is unbounded. Our general solution for this problem
        // is to use [`ore::stack::RecursionGuard`] to additionally limit the stack
        // depth. That however requires upstream error handling. This function is
        // currently called by the Coordinator after calls to `catalog_transact`,
        // and thus are not allowed to fail. Until that allows errors, we choose
        // to allow the unbounded growth here. We are though somewhat protected by
        // higher levels enforcing their own limits on stack depth (in the parser,
        // transformer/desugarer, and planner).
        ore::stack::maybe_grow(|| Plan::from_mir_inner(expr, arrangements))
    }
/// This method converts a MirRelationExpr into a plan that can be directly rendered.
///
/// The rough structure is that we repeatedly extract map/filter/project operators
/// from each expression we see, bundle them up as a `MapFilterProject` object, and
/// then produce a plan for the combination of that with the next operator.
///
/// The method takes as an argument the existing arrangements for each bound identifier,
/// which it will locally add to and remove from for `Let` bindings (by the end of the
/// call it should contain the same bindings as when it started).
///
/// The result of the method is both a `Plan`, but also a list of arrangements that
/// are certain to be produced, which can be relied on by the next steps in the plan.
/// An empty list of arrangement keys indicates that only a `Collection` stream can
/// be assumed to exist.
This method converts a MirRelationExpr into a plan that can be directly rendered.
The rough structure is that we repeatedly extract map/filter/project operators
from each expression we see, bundle them up as a `MapFilterProject` object, and
then produce a plan for the combination of that with the next operator.

The method takes as an argument the existing arrangements for each bound identifier,
which it will locally add to and remove from for `Let` bindings (by the end of the
call it should contain the same bindings as when it started).

The result of the method is both a `Plan`, but also a list of arrangements that
are certain to be produced, which can be relied on by the next steps in the plan.
An empty list of arrangement keys indicates that only a `Collection` stream can
be assumed to exist.
This method converts a MirRelationExpr into a plan that can be directly rendered . The rough structure is that we repeatedly extract map / filter / project operators from each expression we see bundle them up as a ` MapFilterProject ` object and then produce a plan for the combination of that with the next operator . The method takes as an argument the existing arrangements for each bound identifier which it will locally add to and remove from for ` Let ` bindings ( by the end of the call it should contain the same bindings as when it started ) . The result of the method is both a ` Plan ` but also a list of arrangements that are certain to be produced which can be relied on by the next steps in the plan . An empty list of arrangement keys indicates that only a ` Collection ` stream can be assumed to exist .
pub fn from_mir(
        expr: &MirRelationExpr,
        arrangements: &mut BTreeMap<Id, Vec<Vec<MirScalarExpr>>>,
    ) -> Result<(Self, Vec<Vec<MirScalarExpr>>), ()> {
        // This function is recursive and can overflow its stack, so grow it if
        // needed. The growth here is unbounded. Our general solution for this problem
        // is to use [`ore::stack::RecursionGuard`] to additionally limit the stack
        // depth. That however requires upstream error handling. This function is
        // currently called by the Coordinator after calls to `catalog_transact`,
        // and thus are not allowed to fail. Until that allows errors, we choose
        // to allow the unbounded growth here. We are though somewhat protected by
        // higher levels enforcing their own limits on stack depth (in the parser,
        // transformer/desugarer, and planner).
        ore::stack::maybe_grow(|| Plan::from_mir_inner(expr, arrangements))
    }
pub fn from_mir ( expr : & MirRelationExpr , arrangements : & mut BTreeMap < Id , Vec < Vec < MirScalarExpr > > > , ) -> Result < ( Self , Vec < Vec < MirScalarExpr > > ) , ( ) > { // This function is recursive and can overflow its stack, so grow it if // needed. The growth here is unbounded. Our general solution for this problem // is to use [`ore::stack::RecursionGuard`] to additionally limit the stack // depth. That however requires upstream error handling. This function is // currently called by the Coordinator after calls to `catalog_transact`, // and thus are not allowed to fail. Until that allows errors, we choose // to allow the unbounded growth here. We are though somewhat protected by // higher levels enforcing their own limits on stack depth (in the parser, // transformer/desugarer, and planner). ore :: stack :: maybe_grow ( | | Plan :: from_mir_inner ( expr , arrangements ) ) }
This method converts a MirRelationExpr into a plan that can be directly rendered.
This method converts a MirRelationExpr into a plan that can be directly rendered .
expr
&MirRelationExpr
arrangements
&mut BTreeMap<Id, Vec<Vec<MirScalarExpr>>>
expr
&MirRelationExpr
arrangements
&mut BTreeMap<Id, Vec<Vec<MirScalarExpr>>>