Function unique_field_aliases

datafusion/expr/src/logical_plan/builder.rs:1606–1640

Returns aliases to make field names unique. Returns a vector of optional aliases, one per input field. `None` means keep the original name, `Some(alias)` means rename to the alias to ensure uniqueness. Used when creating [`SubqueryAlias`] or similar operations that strip table qualifiers but need to maintain unique column names. # Example Input fields: `[a, a, b, b, a, a:1]` ([`DFSchema`] valid

(fields: &Fields)

/// Input fields: `[a, a, b, b, a, a:1]` ([`DFSchema`] valid when duplicate fields have different qualifiers)
/// Returns: `[None, Some("a:1"), None, Some("b:1"), Some("a:2"), Some("a:1:1")]`
pub fn unique_field_aliases(fields: &Fields) -> Vec<Option<String>> {
    // Some field names might already come to this function with the count (number of times it appeared)
    // as a suffix e.g. id:1, so there's still a chance of name collisions, for example,
    // if these three fields passed to this function: "col:1", "col" and "col", the function
    // would rename them to -> col:1, col, col:1 causing a posterior error when building the DFSchema.
    // That's why we need the `seen` set, so the fields are always unique.

    // Tracks a mapping between a field name and the number of appearances of that field.
    let mut name_map = HashMap::<&str, usize>::new();
    // Tracks all the fields and aliases that were previously seen.
    let mut seen = HashSet::<Cow<String>>::new();

    fields
        .iter()
        .map(|field| {
            let original_name = field.name();
            let mut name = Cow::Borrowed(original_name);

            let count = name_map.entry(original_name).or_insert(0);

            // Loop until we find a name that hasn't been used.
            while seen.contains(&name) {
                *count += 1;
                name = Cow::Owned(format!("{original_name}:{count}"));
            }

            seen.insert(name.clone());

            match name {
                Cow::Borrowed(_) => None,
                Cow::Owned(alias) => Some(alias),
            }
        })
        .collect()
}

fn mark_field(schema: &DFSchema) -> (Option<TableReference>, Arc<Field>) {
    let mut table_references = schema