use std::collections::BTreeMap;
use crate::adapters::dispatch::main::dialect::sql_adapter::sql_adapter;
use crate::column_types::models::{ColumnType, Warehouse};
use crate::contract::constants::{
MISSING_DECLARATION, MISSING_PHYSICAL_COLUMN, RELATION_MISSING, TYPE_MISMATCH,
};
use crate::contract::models::ContractFinding;
use crate::load_naming::main::is_load_column::is_load_column;
use crate::load_naming::models::Compat;
use crate::loader::models::TableSpec;
use crate::project::models::Contract;
use crate::schema_plan::models::LiveColumn;
pub(crate) fn findings(
declared: &BTreeMap<String, ColumnType>,
contract: Contract,
live: Option<&[LiveColumn]>,
(warehouse, compat, relation): (Warehouse, Compat, &str),
) -> Vec<ContractFinding> {
let Some(live) = live else {
return vec![ContractFinding {
column: None,
declared_type: None,
kind: RELATION_MISSING,
message: format!("physical relation {relation} does not exist"),
physical_type: None,
source_type: None,
}];
};
let declared_type = |name: &str| {
declared
.iter()
.find(|(declared, _)| declared.eq_ignore_ascii_case(name))
};
let mut found: Vec<ContractFinding> = live
.iter()
.filter(|column| !is_own(compat, &column.name))
.filter_map(|column| live_finding(column, declared_type(&column.name), contract, warehouse))
.collect();
found.extend(
declared
.iter()
.filter(|(name, _)| !is_live(live, name))
.map(|(name, column_type)| ContractFinding {
column: Some(name.clone()),
declared_type: Some(column_type.to_string()),
kind: MISSING_PHYSICAL_COLUMN,
message: format!("declared column '{name}' is absent from the physical relation"),
physical_type: None,
source_type: None,
}),
);
found
}
pub(crate) fn is_own(compat: Compat, name: &str) -> bool {
is_load_column(compat, &name.to_ascii_lowercase())
}
pub(crate) fn is_live(live: &[LiveColumn], name: &str) -> bool {
live.iter()
.any(|column| column.name.eq_ignore_ascii_case(name))
}
pub(crate) fn agrees(warehouse: Warehouse, declared: &ColumnType, live: &ColumnType) -> bool {
let sql = |column_type: &ColumnType| {
sql_adapter(warehouse)
.render_loader_logical_type(column_type)
.sql
};
declared == live || sql(declared).eq_ignore_ascii_case(&sql(live))
}
fn live_finding(
column: &LiveColumn,
declared: Option<(&String, &ColumnType)>,
contract: Contract,
warehouse: Warehouse,
) -> Option<ContractFinding> {
let physical = column.column_type.to_string();
match (declared, contract) {
(Some((_, declared)), _) if agrees(warehouse, declared, &column.column_type) => None,
(Some((name, declared)), _) => Some(ContractFinding {
column: Some(name.clone()),
declared_type: Some(declared.to_string()),
kind: TYPE_MISMATCH,
message: format!(
"column '{name}' is declared {declared} but physical type is {physical}"
),
physical_type: Some(physical),
source_type: None,
}),
(None, Contract::Enforced) => Some(ContractFinding {
column: Some(column.name.clone()),
declared_type: None,
kind: MISSING_DECLARATION,
message: format!(
"physical column '{}' ({physical}) is not declared",
column.name
),
physical_type: Some(physical),
source_type: None,
}),
(None, Contract::None) => None,
}
}
pub(crate) fn declared_columns(spec: &TableSpec) -> BTreeMap<String, ColumnType> {
let mut declared: BTreeMap<String, ColumnType> = added_constants(spec)
.map(|(name, column_type, _)| (name.clone(), column_type.clone()))
.collect();
declared.extend(
spec.pinned
.iter()
.map(|(name, column_type)| (name.clone(), spec.loaded_type(name, column_type.clone()))),
);
declared
}
pub(crate) fn added_constants(
spec: &TableSpec,
) -> impl Iterator<Item = &(String, ColumnType, String)> {
spec.constants.iter().filter(|_| spec.files.is_none())
}