use std::collections::BTreeSet;
use crate::load_naming::constants::PAIR;
use crate::load_naming::models::{
LoadedColumn, NameChange, NameRules, NumberedName, OnDuplicateNames,
};
type Members = Vec<(NumberedName, usize)>;
pub(crate) fn numbered_columns(
loaded: Vec<LoadedColumn>,
rules: &NameRules,
) -> Result<(Vec<LoadedColumn>, Vec<NumberedName>), Vec<String>> {
let groups = clash_groups(&loaded);
let mut taken: BTreeSet<String> = groups.iter().map(|(key, _)| key.clone()).collect();
let mut numbered: Members = Vec::new();
let mut problems: Vec<String> = Vec::new();
for (key, indexes) in &groups {
match group_numbers(&loaded, (key, indexes), rules, &taken) {
Ok(members) => {
taken.extend(members.iter().map(|(name, _)| name.column.to_lowercase()));
numbered.extend(members);
}
Err(found) => problems.extend(found),
}
}
match problems.is_empty() {
true => Ok((
numbered_loaded(loaded, &numbered),
numbered.into_iter().map(|(name, _)| name).collect(),
)),
false => Err(problems),
}
}
fn clash_groups(loaded: &[LoadedColumn]) -> Vec<(String, Vec<usize>)> {
let mut groups: Vec<(String, Vec<usize>)> = Vec::new();
for (index, column) in loaded.iter().enumerate() {
let key = column.loaded.to_lowercase();
match groups.iter_mut().find(|(name, _)| *name == key) {
Some((_, indexes)) => indexes.push(index),
None => groups.push((key, vec![index])),
}
}
groups
}
fn numbered_loaded(mut loaded: Vec<LoadedColumn>, numbered: &Members) -> Vec<LoadedColumn> {
for (name, index) in numbered {
let column = &mut loaded[*index];
if column.loaded != name.column {
column.loaded.clone_from(&name.column);
column.change = Some(NameChange::Numbered);
}
}
loaded
}
fn group_numbers(
loaded: &[LoadedColumn],
(key, indexes): (&str, &[usize]),
rules: &NameRules,
taken: &BTreeSet<String>,
) -> Result<Members, Vec<String>> {
let base = &loaded[indexes[0]].loaded;
let recorded: Vec<&NumberedName> = rules
.kept
.iter()
.filter(|kept| numbered_from(&kept.column, base))
.collect();
let (renamed, plain): (Vec<usize>, Vec<usize>) = indexes
.iter()
.partition(|index| loaded[**index].change == Some(NameChange::Renamed));
if indexes.len() < PAIR && recorded.is_empty() {
return Ok(Vec::new());
}
let members = with_kept(sorted_members(loaded, &plain), &recorded);
let refused = refused_clash(loaded, &plain, (rules.on_duplicate_names, base))
.or_else(|| unrecorded_clash(loaded, &members, (&recorded, base), &rules.existing));
if let Some(problem) = refused {
return Err(vec![problem]);
}
let held: BTreeSet<String> = renamed
.iter()
.map(|index| loaded[*index].loaded.to_lowercase())
.chain(members.iter().map(|(name, _)| name.column.to_lowercase()))
.filter(|name| !name.is_empty())
.collect();
given_numbers(
loaded,
members,
(&recorded, rules.max_length),
(held, taken, key),
)
}
fn sorted_members(loaded: &[LoadedColumn], plain: &[usize]) -> Members {
let mut members: Members = plain
.iter()
.map(|index| {
let column = &loaded[*index];
let name = NumberedName {
column: String::new(),
source: column.source.clone(),
repeat: repeat_of(column, loaded),
};
(name, *index)
})
.collect();
members.sort_by(|(left, _), (right, _)| {
(&left.source, left.repeat).cmp(&(&right.source, right.repeat))
});
members
}
fn with_kept(members: Members, recorded: &[&NumberedName]) -> Members {
members
.into_iter()
.map(|(name, index)| (kept_name(name, recorded), index))
.collect()
}
fn kept_name(mut name: NumberedName, recorded: &[&NumberedName]) -> NumberedName {
let kept = recorded
.iter()
.find(|kept| kept.source == name.source && kept.repeat == name.repeat);
if let Some(kept) = kept {
name.column.clone_from(&kept.column);
}
name
}
fn refused_clash(
loaded: &[LoadedColumn],
plain: &[usize],
(on_duplicate_names, base): (OnDuplicateNames, &str),
) -> Option<String> {
if on_duplicate_names != OnDuplicateNames::Fail || plain.len() < PAIR {
return None;
}
let names: Vec<String> = plain
.iter()
.map(|index| shown(&loaded[*index], loaded))
.collect();
Some(format!(
"columns {} {} load as {base}; give them names of their own with rename, or set on_duplicate_names = \"number\"",
names.join(" and "),
both_or_all(names.len())
))
}
fn unrecorded_clash(
loaded: &[LoadedColumn],
members: &Members,
(recorded, base): (&[&NumberedName], &str),
existing: &[String],
) -> Option<String> {
let sources: BTreeSet<&str> = members
.iter()
.map(|(name, _)| name.source.as_str())
.collect();
let unrecorded = !recorded
.iter()
.any(|kept| kept.column.eq_ignore_ascii_case(base));
let live = existing
.iter()
.any(|column| column.eq_ignore_ascii_case(base));
if sources.len() < PAIR || !live || !unrecorded {
return None;
}
let names: Vec<String> = members
.iter()
.map(|(_, index)| shown(&loaded[*index], loaded))
.collect();
Some(format!(
"columns {} now {} load as {base}, which the table already has, and no earlier load recorded which of them it holds; give all but one a name of its own with rename",
names.join(" and "),
both_or_all(names.len())
))
}
fn given_numbers(
loaded: &[LoadedColumn],
members: Members,
(recorded, max_length): (&[&NumberedName], Option<usize>),
(mut held, taken, key): (BTreeSet<String>, &BTreeSet<String>, &str),
) -> Result<Members, Vec<String>> {
let mut number = 0;
let mut problems: Vec<String> = Vec::new();
let mut named: Members = Vec::new();
for (mut name, index) in members {
if name.column.is_empty() {
let own = &loaded[index].loaded;
let (column, next) = free_name(own, number, (&held, taken, key), max_length);
number = next;
problems.extend(gone_problem(loaded, recorded, (&column, index)));
held.insert(column.to_lowercase());
name.column = column;
}
named.push((name, index));
}
match problems.is_empty() {
true => Ok(named),
false => Err(problems),
}
}
fn free_name(
own: &str,
number: usize,
(held, taken, key): (&BTreeSet<String>, &BTreeSet<String>, &str),
max_length: Option<usize>,
) -> (String, usize) {
(number..)
.map(|number| match number {
0 => (own.to_owned(), 1),
_ => (numbered_name(own, number, max_length), number + 1),
})
.find(|(candidate, _)| {
let lower = candidate.to_lowercase();
!held.contains(&lower) && (lower == key || !taken.contains(&lower))
})
.unwrap_or_default()
}
fn gone_problem(
loaded: &[LoadedColumn],
recorded: &[&NumberedName],
(column, index): (&str, usize),
) -> Option<String> {
let gone = recorded
.iter()
.find(|kept| kept.column.eq_ignore_ascii_case(column))?;
(!has_source(loaded, &gone.source)).then(|| {
format!(
"column {column} holds {:?} from earlier loads, which the source no longer has, and {} would now load into it; give {:?} a name of its own with rename, or rename it to {column} if it is the same column under a new name",
gone.source,
shown(&loaded[index], loaded),
loaded[index].source
)
})
}
fn has_source(loaded: &[LoadedColumn], source: &str) -> bool {
loaded.iter().any(|column| column.source == source)
}
fn both_or_all(count: usize) -> &'static str {
match count > PAIR {
true => "all",
false => "both",
}
}
fn numbered_from(column: &str, base: &str) -> bool {
let column = column.to_lowercase();
let base = base.to_lowercase();
if column == base {
return true;
}
let Some(digits) = column
.strip_prefix(&base)
.and_then(|rest| rest.strip_prefix('_'))
else {
return false;
};
!digits.is_empty() && digits.bytes().all(|digit| digit.is_ascii_digit())
}
fn numbered_name(base: &str, number: usize, max_length: Option<usize>) -> String {
let suffix = format!("_{number}");
let kept = max_length.map_or(usize::MAX, |max| max.saturating_sub(suffix.chars().count()));
let head: String = base.chars().take(kept).collect();
format!("{head}{suffix}")
}
pub(crate) fn repeat_of(column: &LoadedColumn, loaded: &[LoadedColumn]) -> usize {
loaded
.iter()
.filter(|earlier| earlier.position < column.position && earlier.source == column.source)
.count()
}
pub(crate) fn repeated(column: &LoadedColumn, loaded: &[LoadedColumn]) -> bool {
loaded
.iter()
.any(|other| other.position != column.position && other.source == column.source)
}
pub(crate) fn shown(column: &LoadedColumn, loaded: &[LoadedColumn]) -> String {
match repeated(column, loaded) {
true => format!("{:?} (column {})", column.source, column.position),
false => format!("{:?}", column.source),
}
}
pub(crate) fn clashes(name: &NumberedName, columns: &[LoadedColumn]) -> bool {
columns.iter().any(|column| {
column.source != name.source
&& (numbered_from(&column.loaded, &name.column)
|| numbered_from(&name.column, &column.loaded))
})
}