use std::collections::HashMap;
use fv_value::{value_to_json, Value};
use serde_json::json;
use crate::Row;
pub type Snapshot = Vec<(String, Row)>;
#[derive(Debug, Clone, PartialEq)]
pub struct Change {
pub object_type: String,
pub rid: String,
pub properties: Vec<(String, Value)>,
pub snapshot: i64,
pub ts: i64,
pub labels: Option<Value>,
pub deleted: bool,
pub datasource: Option<String>,
}
impl Change {
pub fn to_json(&self) -> serde_json::Value {
let mut m = serde_json::Map::new();
m.insert("src".into(), json!("BASE"));
m.insert("objectType".into(), json!(self.object_type));
m.insert("rid".into(), json!(self.rid));
m.insert(
"properties".into(),
serde_json::Value::Object(
self.properties
.iter()
.map(|(k, v)| (k.clone(), value_to_json(v)))
.collect(),
),
);
m.insert("snapshot".into(), json!(self.snapshot));
m.insert("ts".into(), json!(self.ts));
if let Some(labels) = &self.labels {
m.insert("labels".into(), value_to_json(labels));
}
if self.deleted {
m.insert("deleted".into(), json!(true));
}
if let Some(ds) = &self.datasource {
m.insert("datasource".into(), json!(ds));
}
serde_json::Value::Object(m)
}
}
fn business_props(row: &Row) -> Vec<(String, Value)> {
row.iter()
.filter(|(k, _)| k != "rid" && k != "_labels")
.map(|(k, v)| (k.clone(), v.clone()))
.collect()
}
fn row_labels(row: &Row) -> Option<Value> {
row.iter()
.find(|(k, _)| k == "_labels")
.map(|(_, v)| v.clone())
.filter(|v| !matches!(v, Value::Null))
}
#[allow(clippy::too_many_arguments)] pub fn diff_snapshots(
prev: &Snapshot,
curr: &Snapshot,
object_type: &str,
snapshot_id: i64,
ts: i64,
datasource: Option<&str>,
primary: bool,
event_time_column: Option<&str>,
) -> Vec<Change> {
let prev_idx: HashMap<&str, &Row> = prev.iter().map(|(rid, row)| (rid.as_str(), row)).collect();
let curr_idx: HashMap<&str, &Row> = curr.iter().map(|(rid, row)| (rid.as_str(), row)).collect();
let event_ts = |row: Option<&&Row>| -> i64 {
let Some(col) = event_time_column else { return ts };
row.and_then(|r| r.iter().find(|(k, _)| k == col))
.and_then(|(_, v)| match v {
Value::Num(n) if n.is_finite() && *n > 0.0 => Some(*n as i64),
Value::Str(s) => {
let t = s.trim();
t.parse::<f64>()
.ok()
.filter(|n| n.is_finite() && *n > 0.0)
.map(|n| n as i64)
.or_else(|| {
chrono::DateTime::parse_from_rfc3339(t)
.ok()
.map(|d| d.timestamp_millis())
})
}
_ => None,
})
.unwrap_or(ts)
};
let envelope = |rid: &str, props: Vec<(String, Value)>, change_ts: i64| Change {
object_type: object_type.to_string(),
rid: rid.to_string(),
properties: props,
snapshot: snapshot_id,
ts: change_ts,
labels: None,
deleted: false,
datasource: datasource.map(str::to_string),
};
let mut out = Vec::new();
for (rid, row) in curr {
let props = business_props(row);
let row_ts = event_ts(Some(&row));
match prev_idx.get(rid.as_str()) {
None => {
let mut change = envelope(rid, props, row_ts);
change.labels = row_labels(row);
out.push(change);
}
Some(prev_row) => {
let prev_props = business_props(prev_row);
let prev_map: HashMap<&str, &Value> = prev_props.iter().map(|(k, v)| (k.as_str(), v)).collect();
let changed: Vec<(String, Value)> = props
.iter()
.filter(|(k, v)| prev_map.get(k.as_str()).copied() != Some(v))
.map(|(k, v)| (k.clone(), v.clone()))
.collect();
if !changed.is_empty() {
out.push(envelope(rid, changed, row_ts));
}
}
}
}
for (rid, row) in prev {
if curr_idx.contains_key(rid.as_str()) {
continue;
}
if primary {
let mut change = envelope(rid, Vec::new(), ts);
change.deleted = true;
out.push(change);
} else {
let nulled: Vec<(String, Value)> = business_props(row).into_iter().map(|(k, _)| (k, Value::Null)).collect();
if !nulled.is_empty() {
out.push(envelope(rid, nulled, ts));
}
}
}
out
}
#[cfg(test)]
mod event_time_tests {
use super::*;
use fv_value::Value;
fn row(rid: &str, speed: f64, observed: Option<Value>) -> (String, Row) {
let mut r: Row = vec![
("rid".into(), Value::Str(rid.into())),
("speedMps".into(), Value::Num(speed)),
];
if let Some(o) = observed {
r.push(("observedAt".into(), o));
}
(rid.into(), r)
}
#[test]
fn changes_are_stamped_with_the_rows_own_event_time_not_the_scan_clock() {
let curr = vec![
row("v1", 5.0, Some(Value::Num(1_000_000.0))),
row("v2", 6.0, Some(Value::Str("2000000".into()))), row("v3", 7.0, None), ];
let out = diff_snapshots(
&Vec::new(),
&curr,
"Vessel",
1,
9_999_999,
None,
true,
Some("observedAt"),
);
let ts_of = |rid: &str| out.iter().find(|c| c.rid == rid).unwrap().ts;
assert_eq!(ts_of("v1"), 1_000_000);
assert_eq!(ts_of("v2"), 2_000_000);
assert_eq!(ts_of("v3"), 9_999_999);
let iso = vec![row("v4", 8.0, Some(Value::Str("2024-03-01T09:00:00+10:00".into())))];
let out = diff_snapshots(
&Vec::new(),
&iso,
"Vessel",
1,
9_999_999,
None,
true,
Some("observedAt"),
);
assert_eq!(out[0].ts, 1_709_247_600_000); let legacy = diff_snapshots(&Vec::new(), &curr, "Vessel", 1, 9_999_999, None, true, None);
assert!(legacy.iter().all(|c| c.ts == 9_999_999));
}
#[test]
fn a_looped_replay_collapses_instead_of_sawtoothing() {
let a = vec![row("v1", 5.0, Some(Value::Num(1_000.0)))];
let again = diff_snapshots(&a, &a, "Vessel", 2, 8_888, None, true, Some("observedAt"));
assert!(again.is_empty());
let b = vec![row("v1", 9.0, Some(Value::Num(1_000.0)))];
let changed = diff_snapshots(&a, &b, "Vessel", 3, 8_888, None, true, Some("observedAt"));
assert_eq!(changed[0].ts, 1_000);
}
#[test]
fn deletes_are_stamped_at_scan_time_and_junk_event_values_fall_back() {
let prev = vec![row("v1", 5.0, Some(Value::Num(1_000.0)))];
let out = diff_snapshots(&prev, &Vec::new(), "Vessel", 2, 7_777, None, true, Some("observedAt"));
assert!(out[0].deleted);
assert_eq!(out[0].ts, 7_777); let junk = vec![row("v2", 5.0, Some(Value::Str("not-a-time".into())))];
let out = diff_snapshots(&Vec::new(), &junk, "Vessel", 1, 7_777, None, true, Some("observedAt"));
assert_eq!(out[0].ts, 7_777);
}
}