Function plan

src/transform/src/join_implementation.rs:593–668

Creates a delta query plan, and any predicates that need to be lifted. It also returns the number of new arrangements necessary for this plan. The method returns `Err` if any errors occur during planning.

(
        join: &MirRelationExpr,
        input_mapper: &JoinInputMapper,
        available: &[Vec<Vec<MirScalarExpr>>],
        unique_keys: &[Vec<Vec<usize>>],
        cardinalities: &[Option<usize>

    ///
    /// The method returns `Err` if any errors occur during planning.
    pub fn plan(
        join: &MirRelationExpr,
        input_mapper: &JoinInputMapper,
        available: &[Vec<Vec<MirScalarExpr>>],
        unique_keys: &[Vec<Vec<usize>>],
        cardinalities: &[Option<usize>],
        filters: &[FilterCharacteristics],
        optimizer_features: &OptimizerFeatures,
    ) -> Result<(MirRelationExpr, usize), TransformError> {
        let mut new_join = join.clone();

        if let MirRelationExpr::Join {
            inputs,
            equivalences,
            implementation,
        } = &mut new_join
        {
            // Determine a viable order for each relation, or return `Err` if none found.
            let orders = super::optimize_orders(
                equivalences,
                available,
                unique_keys,
                cardinalities,
                filters,
                input_mapper,
                optimizer_features.enable_join_prioritize_arranged,
            )?;

            // Count new arrangements.
            let new_arrangements: usize = orders
                .iter()
                .flat_map(|o| {
                    o.iter().skip(1).filter_map(|(c, key, input)| {
                        if c.arranged() {
                            None
                        } else {
                            Some((input, key))
                        }
                    })
                })
                .collect::<BTreeSet<_>>()
                .len();

            // Convert the order information into specific (input, key, characteristics) information.
            let mut orders = orders
                .into_iter()
                .map(|o| {
                    o.into_iter()
                        .skip(1)
                        .map(|(c, key, r)| (r, key, Some(c)))
                        .collect::<Vec<_>>()
                })
                .collect::<Vec<_>>();

            // Implement arrangements in each of the inputs.
            let (lifted_mfp, lifted_projections) =
                super::implement_arrangements(inputs, available, orders.iter().flatten());