Function get_excluded_columns

datafusion/expr/src/utils.rs:331–385

Find excluded columns in the schema, if any SELECT * EXCLUDE(col1, col2), would return `vec![col1, col2]`

(
    opt_exclude: Option<&ExcludeSelectItem>,
    opt_except: Option<&ExceptSelectItem>,
    schema: &DFSchema,
    qualifier: Option<&TableReference>,
)

/// Find excluded columns in the schema, if any
/// SELECT * EXCLUDE(col1, col2), would return `vec![col1, col2]`
fn get_excluded_columns(
    opt_exclude: Option<&ExcludeSelectItem>,
    opt_except: Option<&ExceptSelectItem>,
    schema: &DFSchema,
    qualifier: Option<&TableReference>,
) -> Result<Vec<Column>> {
    let mut idents = vec![];
    if let Some(excepts) = opt_except {
        idents.push(&excepts.first_element);
        idents.extend(&excepts.additional_elements);
    }
    // Declared outside the `if let` so `idents.extend(exclude_owned.iter())`
    // below can borrow references that outlive the inner scope.
    let exclude_owned: Vec<Ident>;
    if let Some(exclude) = opt_exclude {
        let object_name_to_ident = |name: &ObjectName| -> Result<Ident> {
            if name.0.len() != 1 {
                return plan_err!(
                    "EXCLUDE with multi-part identifiers is not supported: {name}"
                );
            }
            let part = &name.0[0];
            let Some(ident) = part.as_ident() else {
                return plan_err!(
                    "EXCLUDE with non-identifier name part is not supported: {part}"
                );
            };
            Ok(ident.clone())
        };
        exclude_owned = match exclude {
            ExcludeSelectItem::Single(name) => vec![object_name_to_ident(name)?],
            ExcludeSelectItem::Multiple(names) => names
                .iter()
                .map(object_name_to_ident)
                .collect::<Result<Vec<_>>>()?,
        };
        idents.extend(exclude_owned.iter());
    }
    // Excluded columns should be unique
    let n_elem = idents.len();
    let unique_idents = idents.into_iter().collect::<HashSet<_>>();
    // If HashSet size, and vector length are different, this means that some of the excluded columns
    // are not unique. In this case return error.
    if n_elem != unique_idents.len() {
        return plan_err!("EXCLUDE or EXCEPT contains duplicate column names");
    }

    let mut result = vec![];
    for ident in unique_idents.into_iter() {
        let col_name = ident.value.as_str();
        let (qualifier, field) = schema.qualified_field_with_name(qualifier, col_name)?;
        result.push(Column::from((qualifier, field)));
    }
    Ok(result)
}

/// Returns all `Expr`s in the schema, except the `Column`s in the `columns_to_skip`
fn get_exprs_except_skipped(