use crate::column_types::models::ColumnType;
use crate::file_store::models::OpenFolder;
use crate::files_destination::main::plan_replaced_files::plan_replaced_files;
use crate::files_destination::main::read_table_state::read_table_state;
use crate::files_destination::main::repair_table::repair_table;
use crate::files_destination::models::{ReplaceRequest, ReplacedFiles, TableFiles, TablePath};
use crate::loader::errors::LoaderError;
use crate::loader::models::{FilesOutput, TablePlan};
pub(in crate::loader) async fn files_to_replace(
folder: &OpenFolder,
table: &TablePlan,
output: &FilesOutput,
) -> Result<ReplacedFiles, LoaderError> {
let cursor_type = table.spec.cursor.as_ref().and_then(|cursor| {
table
.schema
.write_columns
.iter()
.find(|column| column.name == cursor.column)
.map(|column| column.column_type.clone())
});
let before = repaired_files(folder, &output.path, cursor_type.as_ref()).await?;
plan_replaced_files(&ReplaceRequest {
mode: &table.mode,
listed: &before,
partition: output.path.partition.as_ref(),
cursor_type: cursor_type.as_ref(),
})
.map_err(LoaderError::Invalid)
}
async fn repaired_files(
folder: &OpenFolder,
path: &TablePath,
cursor_type: Option<&ColumnType>,
) -> Result<TableFiles, LoaderError> {
let state = read_table_state(folder, path, cursor_type).await?;
repair_table(folder, &state.pending).await?;
let state = match state.pending.is_empty() {
true => state,
false => read_table_state(folder, path, cursor_type).await?,
};
match state.listed.problems.first() {
Some(problem) => Err(LoaderError::Invalid(problem.clone())),
None => Ok(state.listed),
}
}