1use crate::{DbError, RowKey, Slot, WriteId};
4use coven_format::loss::{Loss, LossCause, LossValues};
5use coven_merge::Rule;
6use sqlive::rusqlite::types::Value;
7
8#[derive(Clone, Debug, PartialEq)]
10pub struct LostValue {
11 pub table: String,
13 pub key: RowKey,
15 pub lost: Lost,
17 pub replaced_by: Replacement,
19 pub frozen: bool,
22 pub(crate) target: LossTarget,
23}
24
25#[derive(Clone, Debug, PartialEq, Eq)]
26pub(crate) enum LossTarget {
27 Removed { row: coven_merge::RowId, generation: u64 },
28 Acknowledgements(Vec<coven_format::dismissal::Dismissal>),
29}
30
31#[derive(Clone, Debug, PartialEq)]
33pub enum Lost {
34 Cell(LostCell),
36 Row(Vec<LostCell>),
38}
39
40#[derive(Clone, Debug, PartialEq)]
42pub struct LostCell {
43 pub column: String,
45 pub value: Value,
47 pub set_by: WriteId,
49}
50
51#[derive(Clone, Debug, PartialEq)]
54pub enum Replacement {
55 Write(WriteId),
57 Rules(Vec<RemovalRule>),
59 SchemaChange {
61 version: u32,
63 },
64 DataDependency {
70 write: WriteId,
72 sources: Vec<ChangeSource>,
74 },
75 NotAuthorized {
77 write: WriteId,
79 reason: RowAuthorizationFailure,
81 },
82}
83
84#[derive(Clone, Debug, PartialEq, Eq)]
86pub enum RowAuthorizationFailure {
87 NotOwner {
90 owner: coven_foundation::id_source::MemberId,
92 },
93 NotAdmin,
96 InvalidForeignKeyEffect,
98}
99
100#[derive(Clone, Debug, PartialEq)]
102pub struct ChangeSource {
103 pub write: WriteId,
105 pub table: String,
107 pub key: RowKey,
109 pub audience: coven_merge::Audience,
111}
112
113#[derive(Clone, Debug, PartialEq, Eq)]
115pub enum RemovalRule {
116 ForeignKey {
118 columns: Vec<String>,
120 parent: String,
122 parent_columns: Vec<String>,
124 },
125 Check {
127 constraint: String,
129 },
130 DeletedCircle {
132 entry: Slot,
134 },
135 OtherAudience,
137 Unique {
139 terms: Vec<String>,
141 partial: Option<String>,
143 },
144}
145
146impl LostValue {
147 pub(crate) fn from_record(record: Loss) -> Result<Self, DbError> {
148 let key = RowKey::decode(&record.row.key)?;
149 let cell = |column, cell: coven_merge::Cell<coven_format::value::Value>| LostCell {
150 column,
151 value: crate::write_encoding::sql_value(&cell.value.value),
152 set_by: cell.write,
153 };
154 let lost = match record.values {
155 LossValues::Cell { column, cell: value } => Lost::Cell(cell(column, value)),
156 LossValues::Row(cells) => {
157 Lost::Row(cells.into_iter().map(|(column, value)| cell(column, value)).collect())
158 }
159 };
160 let original = record.cause.change_write();
161 let replaced_by = match record.cause {
162 LossCause::Write(write) => Replacement::Write(write),
163 LossCause::Rules(rules) => Replacement::Rules(
164 rules
165 .into_iter()
166 .map(|rule| match rule {
167 Rule::ForeignKey(key) => RemovalRule::ForeignKey {
168 columns: key.columns.0,
169 parent: key.parent,
170 parent_columns: key.parent_columns.0,
171 },
172 Rule::Unique(constraint) => RemovalRule::Unique {
173 terms: constraint.terms,
174 partial: constraint.partial,
175 },
176 Rule::Check(constraint) => RemovalRule::Check { constraint },
177 Rule::DeletedCircle(entry) => RemovalRule::DeletedCircle { entry },
178 Rule::OtherAudience => RemovalRule::OtherAudience,
179 })
180 .collect(),
181 ),
182 LossCause::Excluded { version, .. } => Replacement::SchemaChange { version },
183 LossCause::Dependency { write, sources } => Replacement::DataDependency {
184 write,
185 sources: sources
186 .into_iter()
187 .map(|source| {
188 Ok(ChangeSource {
189 write: source.write,
190 key: RowKey::decode(&source.row.key)?,
191 table: source.row.table,
192 audience: source.row.audience,
193 })
194 })
195 .collect::<Result<_, DbError>>()?,
196 },
197 LossCause::NotAuthorized { write, reason } => Replacement::NotAuthorized {
198 write,
199 reason: match reason {
200 coven_format::loss::AuthorizationFailure::NotOwner { owner } => {
201 RowAuthorizationFailure::NotOwner { owner }
202 }
203 coven_format::loss::AuthorizationFailure::NotAdmin => {
204 RowAuthorizationFailure::NotAdmin
205 }
206 coven_format::loss::AuthorizationFailure::InvalidForeignKeyEffect => {
207 RowAuthorizationFailure::InvalidForeignKeyEffect
208 }
209 },
210 },
211 };
212 let row = record.row;
213 let frozen = record.frozen;
214 let target = if matches!(replaced_by, Replacement::Rules(_)) && !frozen {
215 LossTarget::Removed { row: row.clone(), generation: record.generation }
216 } else {
217 let cells = match &lost {
218 Lost::Cell(cell) => std::slice::from_ref(cell),
219 Lost::Row(cells) => cells,
220 };
221 LossTarget::Acknowledgements(if cells.is_empty() {
222 vec![coven_format::dismissal::Dismissal {
223 row: row.clone(),
224 target: coven_format::dismissal::DismissalTarget::EmptyRow,
225 write: original.expect("an empty frozen loss names its original change"),
226 }]
227 } else {
228 cells
229 .iter()
230 .map(|cell| coven_format::dismissal::Dismissal {
231 row: row.clone(),
232 target: coven_format::dismissal::DismissalTarget::Cell(cell.column.clone()),
233 write: cell.set_by,
234 })
235 .collect()
236 })
237 };
238 Ok(LostValue { table: row.table, key, lost, replaced_by, frozen, target })
239 }
240}
241
242#[cfg(test)]
243#[path = "lost_tests.rs"]
244mod tests;