Skip to main content

ic_db/
managed.rs

1//! Insert/update time policy over canonical row bytes, without a mutation overlay.
2
3use crate::{EntitySchema, Error, Timestamp, codec::Decoder};
4
5/// Database-owned timestamp assignment during bounded write preparation.
6#[derive(Clone, Copy, Debug, PartialEq, Eq)]
7pub enum ManagedTimestamp {
8    /// Set on insertion and preserve on replacement.
9    CreatedAt,
10    /// Set on insertion and on a semantic change, preserving no-op timestamps.
11    UpdatedAt,
12}
13
14impl ManagedTimestamp {
15    pub(crate) const fn slot(self) -> usize {
16        match self {
17            Self::CreatedAt => 0,
18            Self::UpdatedAt => 1,
19        }
20    }
21}
22
23#[doc(hidden)]
24pub fn validate_order(values: [Option<Timestamp>; 2]) -> Result<(), Error> {
25    if matches!(values, [Some(created), Some(updated)] if created > updated) {
26        return Err(Error::Corrupt);
27    }
28    Ok(())
29}
30
31// Only these two fixed-width fields need byte positions. All other fields use
32// the existing bounded decoder; no owned values or general slot table is built.
33fn positions(
34    schema: &EntitySchema,
35    bytes: &[u8],
36) -> Result<[Option<(usize, Timestamp)>; 2], Error> {
37    let mut reader = Decoder::new(bytes)?;
38    let mut values = [None; 2];
39    for field in schema.fields {
40        if field.optional && !reader.boolean()? {
41            continue;
42        }
43        if let Some(managed) = field.managed {
44            let offset = reader.position();
45            values[managed.slot()] = Some((offset, reader.timestamp()?));
46        } else {
47            reader.skip(field.value)?;
48        }
49    }
50    reader.finish()?;
51    Ok(values)
52}
53
54// Migration preserves role values even when their declared field names change.
55pub(crate) fn values(schema: &EntitySchema, bytes: &[u8]) -> Result<[Option<Timestamp>; 2], Error> {
56    Ok(positions(schema, bytes)?.map(|entry| entry.map(|(_, value)| value)))
57}
58
59pub(crate) fn validate_insert(
60    schema: &EntitySchema,
61    bytes: &[u8],
62    now: Timestamp,
63) -> Result<(), Error> {
64    if positions(schema, bytes)?
65        .into_iter()
66        .flatten()
67        .any(|(_, value)| value != now)
68    {
69        return Err(Error::ManagedField);
70    }
71    Ok(())
72}
73
74pub(crate) fn replace(
75    schema: &EntitySchema,
76    bytes: &mut [u8],
77    old: &[u8],
78    now: Timestamp,
79) -> Result<bool, Error> {
80    let before = positions(schema, old)?;
81    validate_order(before.map(|entry| entry.map(|(_, value)| value)))?;
82    if bytes == old {
83        return Ok(false);
84    }
85    let after = positions(schema, bytes)?;
86    for (previous, supplied) in before.iter().zip(&after) {
87        if previous.map(|(_, value)| value) != supplied.map(|(_, value)| value) {
88            return Err(Error::ManagedField);
89        }
90    }
91    if before.into_iter().flatten().any(|(_, value)| now < value) {
92        return Err(Error::TimestampRegression);
93    }
94    if let Some((offset, _)) = after[1] {
95        bytes
96            .get_mut(offset..offset + 8)
97            .ok_or(Error::Corrupt)?
98            .copy_from_slice(&now.as_millis().to_le_bytes());
99    }
100    Ok(true)
101}