Function permutation_for_arrangement

src/expr/src/linear.rs:1516–1544

Derive supporting logic to support transforming rows to (key, val) pairs, and back again. We are given as input a list of mappings from columns to key indices, a key length, and an input arity. (The produced key should be the application of the key expressions.) To produce the `val` output, we will identify those input columns not found in the key expressions, and name all other columns. To reco

(
        key: &[impl Columns],
        unthinned_arity: usize,
    )

    /// `compute_types::plan::AvailableCollections`; see the
    /// documentation there for more details.
    pub fn permutation_for_arrangement(
        key: &[impl Columns],
        unthinned_arity: usize,
    ) -> (Vec<usize>, Vec<usize>) {
        let columns_in_key: BTreeMap<_, _> = key
            .iter()
            .enumerate()
            .filter_map(|(i, key_col)| key_col.as_column().map(|c| (c, i)))
            .collect();

        let mut input_cursor = key.len();
        let permutation = (0..unthinned_arity)
            .map(|c| {
                if let Some(c) = columns_in_key.get(&c) {
                    // Column is in key (and thus gone from the value
                    // of the thinned representation)
                    *c
                } else {
                    // Column remains in value of the thinned representation
                    input_cursor += 1;
                    input_cursor - 1
                }
            })
            .collect();
        let thinning = (0..unthinned_arity)
            .filter(|c| !columns_in_key.contains_key(c))
            .collect();
        (permutation, thinning)
    }

    /// Given the permutations (see [`permutation_for_arrangement`] and
    /// (`dataflow::plan::AvailableCollections`) corresponding to two