use serde::Serialize;
use crate::join::JoinReport;
use crate::run::{BatchResult, InputReport};
use crate::summarize::SummaryOutput;
use crate::table::{Column, Value};
use crate::write::WrittenFile;
#[derive(Debug, Clone, Serialize, schemars::JsonSchema)]
pub struct BatchOutput {
pub measure: String,
pub grain: Vec<String>,
pub inputs: InputReport,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub joins: Vec<JoinReport>,
pub columns: Vec<Column>,
pub total_rows: u64,
pub offset: u64,
pub returned_rows: u64,
pub truncated: bool,
pub rows: Vec<Vec<Value>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub summary: Option<SummaryOutput>,
#[serde(skip_serializing_if = "Option::is_none")]
pub output: Option<WrittenFile>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub warnings: Vec<String>,
}
impl BatchOutput {
pub fn new(res: &BatchResult, joins: Vec<JoinReport>, offset: u64, limit: Option<u64>) -> Self {
let total = res.table.rows.len() as u64;
let start = offset.min(total) as usize;
let end = limit.map_or(total as usize, |l| {
(start as u64).saturating_add(l).min(total) as usize
});
let mut warnings = res.warnings.clone();
for j in &joins {
warnings.extend(j.warnings.iter().cloned());
}
BatchOutput {
measure: res.measure.clone(),
grain: res.grain.clone(),
inputs: res.inputs.clone(),
joins,
columns: res.table.columns.clone(),
total_rows: total,
offset: start as u64,
returned_rows: (end - start) as u64,
truncated: (end as u64) < total,
rows: res.table.rows[start..end].to_vec(),
summary: None,
output: None,
warnings,
}
}
}