Skip to main content

coven_database/
snapshot_write.rs

1//! Audience snapshots stream the counted prefix from one pinned transaction.
2use crate::internal_schema::WRITE_DEVICE_SQL;
3use crate::sqlite::StoreSql;
4use crate::store_call::StoreCall;
5use crate::write_encoding::{counter, decoded, slot_counter};
6use crate::write_failure::{hosted, Hosted};
7use crate::{write_schema::WriteSchema, DbError};
8use coven_format::{
9    admin::SnapshotId,
10    merge_fields,
11    snapshot::{section, SnapshotEncoder, SnapshotHeader, SnapshotRecord, SECTIONS},
12    snapshot_rows::{AppliedWrite, SyncedColumn},
13};
14use coven_merge::{Audience, WriteId};
15use std::collections::BTreeSet;
16
17/// A snapshot failed to read, encode or reach its plaintext consumer.
18#[derive(Debug, thiserror::Error)]
19pub enum SnapshotWriteError<E> {
20    /// Reading committed data failed.
21    #[error(transparent)]
22    Database(#[from] DbError),
23    /// A record could not be encoded.
24    #[error(transparent)]
25    Format(#[from] coven_format::Error),
26    /// The consumer refused a frame.
27    #[error("snapshot output: {0}")]
28    Output(E),
29}
30
31impl<E: coven_foundation::task::CarriesBug> coven_foundation::task::CarriesBug
32    for SnapshotWriteError<E>
33{
34    fn bug(&self) -> Option<&coven_foundation::task::Bug> {
35        match self {
36            Self::Database(error) => error.bug(),
37            Self::Format(_) => None,
38            Self::Output(error) => error.bug(),
39        }
40    }
41}
42
43/// Returns the snapshot's breaking version, read in the transaction that
44/// reads its schema version (ยง16.3).
45pub(crate) fn write<E>(
46    db: &StoreSql,
47    call: &StoreCall<'_>,
48    schema: &WriteSchema,
49    id: SnapshotId,
50    begin: impl FnOnce(&SnapshotHeader) -> Result<(), E>,
51    mut emit: impl FnMut(Vec<u8>) -> Result<(), E>,
52) -> Result<u32, SnapshotWriteError<E>> {
53    let covers = crate::sequence::applied(db)?;
54    let audience = id.audience.clone();
55    let removed = crate::published::removals(db, call, &schema.schema, &schema.rules)?;
56    let mut counts = [0; SECTIONS];
57    let mut columns = BTreeSet::new();
58    crate::snapshot_view::rows(db, call, schema, &audience, |row| {
59        counts[section::MERGE] += 1;
60        columns.extend(
61            row.state.cells().keys().map(|column| (row.state.row().table.clone(), column.clone())),
62        );
63        Ok::<_, DbError>(())
64    })?;
65    crate::snapshot_view::losses(db, call, &removed, &audience, |loss| {
66        counts[section::LOSS] += 1;
67        if let coven_format::loss::LossValues::Cell { column, .. } = &loss.values {
68            columns.insert((loss.row.table.clone(), column.clone()));
69        }
70        Ok::<_, DbError>(())
71    })?;
72    counts[section::WRITE] = db
73        .query_row(
74            "SELECT count(*) FROM _coven_writes WHERE slot<=?1",
75            [covers.to_be_bytes()],
76            |r| r.get::<_, i64>(0).map(|n| n as u64),
77        )
78        .map_err(DbError::from)?;
79    counts[section::COLUMN] = columns.len() as u64;
80    crate::write_sources::visit_evidence(db, &audience, |_| {
81        counts[section::AUTHORED] += 1;
82        Ok::<_, DbError>(())
83    })?;
84    crate::snapshot_view::creations(db, &audience, |_| {
85        counts[section::CREATION] += 1;
86        Ok::<_, DbError>(())
87    })?;
88    let evidence = crate::authorship::evidence(
89        db,
90        call,
91        schema,
92        &audience,
93        crate::authorship::Author {
94            device: id.device,
95            member: crate::store_state_tables::device_member(db, id.device)?,
96        },
97    )?;
98    counts[section::EVIDENCE] = evidence.len() as u64;
99    if audience == Audience::Store {
100        for (at, kind) in [
101            (section::ADMIN, "admin"),
102            (section::KEY_COPY, "key"),
103            (section::ANNOUNCEMENT, "announcement"),
104        ] {
105            counts[at] = db
106                .query_row(
107                    "SELECT count(*) FROM _coven_slot_records WHERE kind=?1 AND slot<=?2",
108                    sqlive::rusqlite::params![kind, covers.to_be_bytes()],
109                    |r| r.get::<_, i64>(0).map(|n| n as u64),
110                )
111                .map_err(DbError::from)?;
112        }
113    }
114    let claims = crate::sequence::claims(db)?;
115    counts[section::CLAIM] = claims.len() as u64;
116    let breaking = crate::raise_capture::breaking_version(db)?;
117    let (mut encoder, header) = SnapshotEncoder::start(SnapshotHeader {
118        id,
119        schema_version: crate::transaction_constants::schema_version(db, call)?,
120        covers,
121        counts,
122    })?;
123    begin(encoder.header()).map_err(SnapshotWriteError::Output)?;
124    emit(header).map_err(SnapshotWriteError::Output)?;
125    let mut record = |record| emit(encoder.record(record)?).map_err(SnapshotWriteError::Output);
126    db.for_each(&format!("SELECT timestamp,number,read_through,slot FROM _coven_writes WHERE slot<=?1 ORDER BY {WRITE_DEVICE_SQL},number"),[covers.to_be_bytes()],|r|hosted(|| record(SnapshotRecord::Write(read_write(r).map_err(DbError::from)?)))).map_err(Hosted::into_inner)?;
127    for (table, column) in columns {
128        record(SnapshotRecord::Column(SyncedColumn { table, column }))?;
129    }
130    crate::snapshot_view::rows(db, call, schema, &audience, |row| {
131        record(SnapshotRecord::Merge(row))
132    })?;
133    crate::snapshot_view::losses(db, call, &removed, &audience, |loss| {
134        record(SnapshotRecord::Loss(loss))
135    })?;
136    crate::write_sources::visit_evidence(db, &audience, |authored| {
137        record(SnapshotRecord::Authored(authored))
138    })?;
139    crate::snapshot_view::creations(db, &audience, |creation| {
140        record(SnapshotRecord::Creation(creation))
141    })?;
142    for evidence in evidence {
143        record(SnapshotRecord::Evidence(evidence))?;
144    }
145    if audience == Audience::Store {
146        for kind in ["admin", "key", "announcement"] {
147            db.for_each("SELECT slot,record FROM _coven_slot_records WHERE kind=?1 AND slot<=?2 ORDER BY slot",sqlive::rusqlite::params![kind,covers.to_be_bytes()],|r| hosted(|| {
148                let original=coven_format::floor::OriginalSlot {slot:slot_counter(r.get(0).map_err(DbError::from)?).map_err(DbError::from)?,object:r.get(1).map_err(DbError::from)?};
149                record(match kind {"admin"=>SnapshotRecord::Admin(original),"key"=>SnapshotRecord::KeyCopy(original),_=>SnapshotRecord::Announcement(original)})
150            })).map_err(Hosted::into_inner)?;
151        }
152    }
153    for claim in claims {
154        record(SnapshotRecord::Claim(claim))?;
155    }
156    emit(encoder.finish()?).map_err(SnapshotWriteError::Output)?;
157    Ok(breaking)
158}
159
160pub(crate) fn read_write(r: &sqlive::rusqlite::Row<'_>) -> sqlive::rusqlite::Result<AppliedWrite> {
161    let timestamp = decoded(merge_fields::decode_timestamp(&r.get::<_, Vec<u8>>(0)?))?;
162    Ok(AppliedWrite {
163        id: WriteId { device: timestamp.device(), number: counter(r.get(1)?)? },
164        timestamp,
165        read_through: counter(r.get(2)?)?,
166        slot: slot_counter(r.get(3)?)?,
167    })
168}
169
170#[cfg(test)]
171#[path = "snapshot_write_tests.rs"]
172pub(crate) mod tests;