use super::*;
#[non_exhaustive]
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub enum DiagnosticSeverity {
Warning,
Error,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct ComparisonDiagnostic {
pub code: String,
pub severity: DiagnosticSeverity,
}
impl ComparisonDiagnostic {
#[must_use]
pub fn message(&self) -> &'static str {
match self.code.as_str() {
"MissingName" => "set a non-empty comparison plan name",
"MissingTarget" => "configure a target source or selector",
"MissingAgainst" => "configure at least one comparison source or selector",
"MissingComparator" => "configure at least one comparator",
"FutureWindowExcluded" => "advance known-at or provide an earlier-available window",
"MissingEventTime" => {
"provide event timestamps or choose processing-position normalization"
}
"TemporalAxisMismatch" => "align the plan axis with the recorded window axis",
"SelfComparison" => "make target and comparison selectors disjoint",
"RuntimeNonSerializablePlan" => "use serializable selectors for portable execution",
_ => "inspect the prepared artifact and plan fields for the invalid contract",
}
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct ComparatorSummary {
#[serde(rename = "comparatorName")]
pub comparator_name: String,
#[serde(rename = "rowCount")]
pub row_count: usize,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct RowRange {
pub start: i64,
pub end: i64,
pub axis: TemporalAxis,
pub clock: Option<String>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct RowPoint {
pub axis: TemporalAxis,
pub magnitude: i64,
pub clock: Option<String>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub enum ComparisonSide {
Target,
Against,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub enum ContainmentStatus {
Contained,
NotContained,
LeftOverhang,
RightOverhang,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub enum LeadLagTransition {
Start,
End,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub enum LeadLagDirection {
Equal,
TargetLeads,
TargetLags,
MissingComparison,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct LeadLagSummary {
#[serde(rename = "transition")]
pub transition: LeadLagTransition,
#[serde(rename = "axis")]
pub axis: TemporalAxis,
#[serde(rename = "toleranceMagnitude")]
pub tolerance_magnitude: i64,
#[serde(rename = "rowCount")]
pub row_count: usize,
#[serde(rename = "targetLeadCount")]
pub target_lead_count: usize,
#[serde(rename = "targetLagCount")]
pub target_lag_count: usize,
#[serde(rename = "equalCount")]
pub equal_count: usize,
#[serde(rename = "missingComparisonCount")]
pub missing_comparison_count: usize,
#[serde(rename = "outsideToleranceCount")]
pub outside_tolerance_count: usize,
#[serde(rename = "minimumDeltaMagnitude")]
pub minimum_delta_magnitude: Option<i64>,
#[serde(rename = "maximumDeltaMagnitude")]
pub maximum_delta_magnitude: Option<i64>,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct CoverageSummary {
#[serde(rename = "windowName")]
pub window_name: String,
pub key: String,
pub partition: Option<String>,
#[serde(rename = "targetMagnitude")]
pub target_magnitude: f64,
#[serde(rename = "targetMagnitudeExact")]
pub target_magnitude_exact: i128,
#[serde(rename = "coveredMagnitude")]
pub covered_magnitude: f64,
#[serde(rename = "coveredMagnitudeExact")]
pub covered_magnitude_exact: i128,
#[serde(rename = "coverageRatio")]
pub coverage_ratio: f64,
}
#[non_exhaustive]
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub enum ComparisonFinality {
Final,
Provisional,
Revised,
Retracted,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct ComparisonRowFinality {
#[serde(rename = "rowType")]
pub row_type: String,
#[serde(rename = "rowId")]
pub row_id: String,
pub finality: ComparisonFinality,
pub reason: String,
pub version: u32,
#[serde(rename = "supersedesRowId")]
pub supersedes_row_id: Option<String>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub enum AsOfDirection {
Previous,
Next,
Nearest,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub enum AsOfMatchStatus {
Exact,
Matched,
NoMatch,
FutureRejected,
Ambiguous,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct OverlapRow {
#[serde(rename = "windowName")]
pub window_name: String,
pub key: String,
pub partition: Option<String>,
pub range: RowRange,
#[serde(rename = "targetRecordIds")]
pub target_record_ids: Vec<String>,
#[serde(rename = "againstRecordIds")]
pub against_record_ids: Vec<String>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct ResidualRow {
#[serde(rename = "windowName")]
pub window_name: String,
pub key: String,
pub partition: Option<String>,
pub range: RowRange,
#[serde(rename = "targetRecordIds")]
pub target_record_ids: Vec<String>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct MissingRow {
#[serde(rename = "windowName")]
pub window_name: String,
pub key: String,
pub partition: Option<String>,
pub range: RowRange,
#[serde(rename = "againstRecordIds")]
pub against_record_ids: Vec<String>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct CoverageRow {
#[serde(rename = "windowName")]
pub window_name: String,
pub key: String,
pub partition: Option<String>,
pub range: RowRange,
#[serde(rename = "targetMagnitude")]
pub target_magnitude: i64,
#[serde(rename = "coveredMagnitude")]
pub covered_magnitude: i64,
#[serde(rename = "targetRecordIds")]
pub target_record_ids: Vec<String>,
#[serde(rename = "againstRecordIds")]
pub against_record_ids: Vec<String>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct GapRow {
#[serde(rename = "windowName")]
pub window_name: String,
pub key: String,
pub partition: Option<String>,
pub range: RowRange,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct SymmetricDifferenceRow {
#[serde(rename = "windowName")]
pub window_name: String,
pub key: String,
pub partition: Option<String>,
pub range: RowRange,
pub side: ComparisonSide,
#[serde(rename = "targetRecordIds")]
pub target_record_ids: Vec<String>,
#[serde(rename = "againstRecordIds")]
pub against_record_ids: Vec<String>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct ContainmentRow {
#[serde(rename = "windowName")]
pub window_name: String,
pub key: String,
pub partition: Option<String>,
pub range: RowRange,
pub status: ContainmentStatus,
#[serde(rename = "targetRecordIds")]
pub target_record_ids: Vec<String>,
#[serde(rename = "containerRecordIds")]
pub container_record_ids: Vec<String>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct LeadLagRow {
#[serde(rename = "windowName")]
pub window_name: String,
pub key: String,
pub partition: Option<String>,
pub transition: LeadLagTransition,
pub axis: TemporalAxis,
#[serde(rename = "targetPoint")]
pub target_point: RowPoint,
#[serde(rename = "comparisonPoint")]
pub comparison_point: Option<RowPoint>,
#[serde(rename = "deltaMagnitude")]
pub delta_magnitude: Option<i64>,
#[serde(rename = "toleranceMagnitude")]
pub tolerance_magnitude: i64,
#[serde(rename = "isWithinTolerance")]
pub is_within_tolerance: bool,
pub direction: LeadLagDirection,
#[serde(rename = "targetRecordId")]
pub target_record_id: String,
#[serde(rename = "comparisonRecordId")]
pub comparison_record_id: Option<String>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct AsOfRow {
#[serde(rename = "windowName")]
pub window_name: String,
pub key: String,
pub partition: Option<String>,
pub axis: TemporalAxis,
pub direction: AsOfDirection,
#[serde(rename = "targetPoint")]
pub target_point: RowPoint,
#[serde(rename = "matchedPoint")]
pub matched_point: Option<RowPoint>,
#[serde(rename = "distanceMagnitude")]
pub distance_magnitude: Option<i64>,
#[serde(rename = "toleranceMagnitude")]
pub tolerance_magnitude: i64,
pub status: AsOfMatchStatus,
#[serde(rename = "targetRecordId")]
pub target_record_id: String,
#[serde(rename = "matchedRecordId")]
pub matched_record_id: Option<String>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct ComparisonRows {
pub overlap: Arc<Vec<OverlapRow>>,
pub residual: Arc<Vec<ResidualRow>>,
pub missing: Arc<Vec<MissingRow>>,
pub coverage: Arc<Vec<CoverageRow>>,
pub gap: Arc<Vec<GapRow>>,
#[serde(rename = "symmetricDifference")]
pub symmetric_difference: Arc<Vec<SymmetricDifferenceRow>>,
pub containment: Arc<Vec<ContainmentRow>>,
#[serde(rename = "leadLag")]
pub lead_lag: Arc<Vec<LeadLagRow>>,
#[serde(rename = "asOf")]
pub as_of: Arc<Vec<AsOfRow>>,
}
impl Default for ComparisonRows {
fn default() -> Self {
Self {
overlap: Arc::new(Vec::new()),
residual: Arc::new(Vec::new()),
missing: Arc::new(Vec::new()),
coverage: Arc::new(Vec::new()),
gap: Arc::new(Vec::new()),
symmetric_difference: Arc::new(Vec::new()),
containment: Arc::new(Vec::new()),
lead_lag: Arc::new(Vec::new()),
as_of: Arc::new(Vec::new()),
}
}
}
#[derive(Default)]
pub(super) struct RowAccumulator {
pub(super) overlap: Vec<OverlapRow>,
pub(super) residual: Vec<ResidualRow>,
pub(super) missing: Vec<MissingRow>,
pub(super) coverage: Vec<CoverageRow>,
pub(super) gap: Vec<GapRow>,
pub(super) symmetric_difference: Vec<SymmetricDifferenceRow>,
pub(super) containment: Vec<ContainmentRow>,
pub(super) lead_lag: Vec<LeadLagRow>,
pub(super) as_of: Vec<AsOfRow>,
}
impl RowAccumulator {
pub(super) fn into_shared(self) -> ComparisonRows {
ComparisonRows {
overlap: Arc::new(self.overlap),
residual: Arc::new(self.residual),
missing: Arc::new(self.missing),
coverage: Arc::new(self.coverage),
gap: Arc::new(self.gap),
symmetric_difference: Arc::new(self.symmetric_difference),
containment: Arc::new(self.containment),
lead_lag: Arc::new(self.lead_lag),
as_of: Arc::new(self.as_of),
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct ComparisonResult {
pub schema: String,
#[serde(rename = "schemaVersion")]
pub schema_version: u32,
pub artifact: String,
#[serde(skip)]
pub plan: ComparisonPlan,
#[serde(rename = "planName")]
pub plan_name: String,
#[serde(rename = "isValid")]
pub is_valid: bool,
pub diagnostics: Vec<ComparisonDiagnostic>,
pub prepared: Option<Value>,
pub aligned: Option<Value>,
#[serde(rename = "knownAt")]
pub known_at: Option<RowPoint>,
#[serde(rename = "evaluationHorizon")]
pub evaluation_horizon: Option<RowPoint>,
#[serde(rename = "comparatorSummaries")]
pub comparator_summaries: Vec<ComparatorSummary>,
#[serde(rename = "coverageSummaries")]
pub coverage_summaries: Vec<CoverageSummary>,
pub rows: ComparisonRows,
#[serde(skip)]
pub overlap_rows: Arc<Vec<OverlapRow>>,
#[serde(skip)]
pub residual_rows: Arc<Vec<ResidualRow>>,
#[serde(skip)]
pub missing_rows: Arc<Vec<MissingRow>>,
#[serde(skip)]
pub coverage_rows: Arc<Vec<CoverageRow>>,
#[serde(skip)]
pub gap_rows: Arc<Vec<GapRow>>,
#[serde(skip)]
pub symmetric_difference_rows: Arc<Vec<SymmetricDifferenceRow>>,
#[serde(skip)]
pub containment_rows: Arc<Vec<ContainmentRow>>,
#[serde(skip)]
pub lead_lag_rows: Arc<Vec<LeadLagRow>>,
#[serde(skip)]
pub lead_lag_summaries: Vec<LeadLagSummary>,
#[serde(skip)]
pub as_of_rows: Arc<Vec<AsOfRow>>,
#[serde(rename = "rowFinalities")]
pub row_finalities: Vec<ComparisonRowFinality>,
#[serde(rename = "extensionMetadata")]
pub extension_metadata: Vec<ComparisonExtensionMetadata>,
}