use schema_model::model::aggregation::{Aggregation, AggregationColumn, AggregationType};
use schema_model::model::table::Table;
use schema_model::model::types::DatabaseType;
pub fn destination_table_name(
database_type: DatabaseType,
table: &Table,
aggregation: &Aggregation,
) -> String {
let destination = aggregation.destination_table();
if destination.contains('.') {
destination.to_string()
} else {
database_type.qualified_name(table.schema_name(), destination)
}
}
pub fn row_value(column: &AggregationColumn) -> String {
match column.aggregation_type() {
AggregationType::Count => "1".to_string(),
AggregationType::Sum => format!("coalesce({}, 0)", column.source_column()),
}
}
pub fn criteria_predicate(aggregation: &Aggregation) -> Option<String> {
aggregation
.criteria()
.map(str::trim)
.filter(|c| !c.is_empty())
.map(|c| format!("({})", c))
}
pub fn watched_columns(aggregation: &Aggregation) -> Option<Vec<String>> {
if criteria_predicate(aggregation).is_some() {
return None;
}
let mut columns: Vec<String> = Vec::new();
for column in aggregation.aggregation_columns() {
if column.aggregation_type() == AggregationType::Sum {
columns.push(column.source_column().to_string());
}
}
for group in aggregation.aggregation_groups() {
match group.source_derived_from().map(str::trim) {
Some(derived) if !derived.is_empty() => columns.push(derived.to_string()),
_ => columns.push(group.source().to_string()),
}
}
columns.push(aggregation.date_column().to_string());
Some(columns)
}