pub fn column_names(
        &self,
        predicate: &Predicate,
        columns: Selection<'_>,
        dst: &mut BTreeSet<String>,
    ) {
        // Determine the set of columns in this row group that are not already
        // present in `dst`, i.e., they haven't been identified in other row
        // groups already.
        let candidate_columns = self
            .all_columns_by_name
            .iter()
            .filter_map(|(name, &id)| match dst.contains(name) {
                // N.B there is bool::then() but it's currently unstable.
                true => None,
                false => match columns {
                    Selection::All => Some((name, &self.columns[id])),
                    Selection::Some(names) => {
                        if names.iter().any(|selection| name == selection) {
                            Some((name, &self.columns[id]))
                        } else {
                            None
                        }
                    }
                },
            })
            .collect::<Vec<_>>();

        match self.row_ids_from_predicate(predicate) {
            RowIDsOption::None(_) => {} // nothing matches predicate
            RowIDsOption::Some(row_ids) => {
                let row_ids = row_ids.to_vec();

                for (name, column) in candidate_columns {
                    if column.has_non_null_value(&row_ids) {
                        dst.insert(name.to_owned());
                    }
                }
            }
            RowIDsOption::All(_) => {
                for (name, column) in candidate_columns {
                    if column.has_any_non_null_value() {
                        dst.insert(name.to_owned());
                    }
                }
            }
        }
    }
/// Given the predicate (which may be empty), determine a set of rows
/// contained in this row group that satisfy it. Any column that contains a
/// non-null value at any of these row positions is then included in the
/// results, which are added to `dst`.
///
/// As an optimisation, the contents of `dst` are checked before execution
/// and any columns already existing in the set are not interrogated.
///
/// If you are familiar with InfluxDB, this is essentially an implementation
/// of `SHOW TAG KEYS`.
Given the predicate (which may be empty), determine a set of rows
contained in this row group that satisfy it. Any column that contains a
non-null value at any of these row positions is then included in the
results, which are added to `dst`.

As an optimisation, the contents of `dst` are checked before execution
and any columns already existing in the set are not interrogated.

If you are familiar with InfluxDB, this is essentially an implementation
of `SHOW TAG KEYS`.
Given the predicate ( which may be empty ) determine a set of rows contained in this row group that satisfy it . Any column that contains a non - null value at any of these row positions is then included in the results which are added to ` dst ` . As an optimisation the contents of ` dst ` are checked before execution and any columns already existing in the set are not interrogated . If you are familiar with InfluxDB this is essentially an implementation of ` SHOW TAG KEYS ` .
pub fn column_names(
        &self,
        predicate: &Predicate,
        columns: Selection<'_>,
        dst: &mut BTreeSet<String>,
    ) {
        // Determine the set of columns in this row group that are not already
        // present in `dst`, i.e., they haven't been identified in other row
        // groups already.
        let candidate_columns = self
            .all_columns_by_name
            .iter()
            .filter_map(|(name, &id)| match dst.contains(name) {
                // N.B there is bool::then() but it's currently unstable.
                true => None,
                false => match columns {
                    Selection::All => Some((name, &self.columns[id])),
                    Selection::Some(names) => {
                        if names.iter().any(|selection| name == selection) {
                            Some((name, &self.columns[id]))
                        } else {
                            None
                        }
                    }
                },
            })
            .collect::<Vec<_>>();
        match self.row_ids_from_predicate(predicate) {
            RowIDsOption::None(_) => {} // nothing matches predicate
            RowIDsOption::Some(row_ids) => {
                let row_ids = row_ids.to_vec();
                for (name, column) in candidate_columns {
                    if column.has_non_null_value(&row_ids) {
                        dst.insert(name.to_owned());
                    }
                }
            }
            RowIDsOption::All(_) => {
                for (name, column) in candidate_columns {
                    if column.has_any_non_null_value() {
                        dst.insert(name.to_owned());
                    }
                }
            }
        }
    }
pub fn column_names ( & self , predicate : & Predicate , columns : Selection < ' _ > , dst : & mut BTreeSet < String > , ) { // Determine the set of columns in this row group that are not already // present in `dst`, i.e., they haven't been identified in other row // groups already. let candidate_columns = self . all_columns_by_name . iter ( ) . filter_map ( | ( name , & id ) | match dst . contains ( name ) { // N.B there is bool::then() but it's currently unstable. true => None , false => match columns { Selection :: All => Some ( ( name , & self . columns [ id ] ) ) , Selection :: Some ( names ) => { if names . iter ( ) . any ( | selection | name == selection ) { Some ( ( name , & self . columns [ id ] ) ) } else { None } } } , } ) . collect :: < Vec < _ > > ( ) ; match self . row_ids_from_predicate ( predicate ) { RowIDsOption :: None ( _ ) => { } // nothing matches predicate RowIDsOption :: Some ( row_ids ) => { let row_ids = row_ids . to_vec ( ) ; for ( name , column ) in candidate_columns { if column . has_non_null_value ( & row_ids ) { dst . insert ( name . to_owned ( ) ) ; } } } RowIDsOption :: All ( _ ) => { for ( name , column ) in candidate_columns { if column . has_any_non_null_value ( ) { dst . insert ( name . to_owned ( ) ) ; } } } } }
Given the predicate (which may be empty), determine a set of rows
contained in this row group that satisfy it.
Given the predicate ( which may be empty ) determine a set of rows contained in this row group that satisfy it .
&self
predicate
&Predicate
columns
Selection<'_>
dst
&mut BTreeSet<String>
&self
predicate
&Predicate
columns
Selection<'_>
dst
&mut BTreeSet<String>