1use 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#[derive(Debug, thiserror::Error)]
19pub enum SnapshotWriteError<E> {
20 #[error(transparent)]
22 Database(#[from] DbError),
23 #[error(transparent)]
25 Format(#[from] coven_format::Error),
26 #[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
43pub(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;