Skip to main content

appstruct_migrate/
diff.rs

1mod indexes;
2mod seeds;
3use self::indexes::diff_indexes;
4use self::seeds::diff_seeds;
5use crate::{
6    ColumnSchema, DatabaseSchema, ForeignKeySchema, IndexSchema, TableSchema,
7    UniqueConstraintSchema,
8};
9use serde::{Deserialize, Serialize};
10use std::collections::BTreeMap;
11
12#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
13#[serde(rename_all = "snake_case")]
14pub enum SchemaRisk {
15    NonDestructive,
16    RequiresInput,
17    Destructive,
18}
19
20#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
21#[serde(rename_all = "snake_case")]
22pub enum ExecutionRisk {
23    Online,
24    MayLock,
25    ManualReview,
26}
27
28#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
29pub struct ChangeRisk {
30    pub schema: SchemaRisk,
31    pub execution: ExecutionRisk,
32}
33
34#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
35#[serde(tag = "kind", rename_all = "snake_case")]
36pub enum SchemaChange {
37    AddTable {
38        table: TableSchema,
39    },
40    RemoveTable {
41        table: TableSchema,
42    },
43    RenameTable {
44        before: TableSchema,
45        after: TableSchema,
46    },
47    AddColumn {
48        table: String,
49        column: ColumnSchema,
50    },
51    RemoveColumn {
52        table: String,
53        column: ColumnSchema,
54    },
55    AlterColumn {
56        table: String,
57        before: ColumnSchema,
58        after: ColumnSchema,
59    },
60    AddUniqueConstraint {
61        constraint: UniqueConstraintSchema,
62    },
63    RemoveUniqueConstraint {
64        constraint: UniqueConstraintSchema,
65    },
66    AddIndex {
67        index: IndexSchema,
68    },
69    RemoveIndex {
70        index: IndexSchema,
71    },
72    AddSeed {
73        seed: crate::SeedSchema,
74    },
75    RemoveSeed {
76        seed: crate::SeedSchema,
77    },
78    AddForeignKey {
79        foreign_key: ForeignKeySchema,
80    },
81    RemoveForeignKey {
82        foreign_key: ForeignKeySchema,
83    },
84}
85
86#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
87pub struct PlannedChange {
88    pub change: SchemaChange,
89    pub risk: ChangeRisk,
90}
91
92#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
93pub struct MigrationPlan {
94    pub changes: Vec<PlannedChange>,
95}
96
97impl MigrationPlan {
98    #[must_use]
99    pub fn is_empty(&self) -> bool {
100        self.changes.is_empty()
101    }
102
103    #[must_use]
104    pub fn is_blocked(&self) -> bool {
105        self.changes.iter().any(|change| {
106            change.risk.schema != SchemaRisk::NonDestructive
107                || change.risk.execution != ExecutionRisk::Online
108        })
109    }
110}
111
112#[must_use]
113pub fn diff(before: &DatabaseSchema, after: &DatabaseSchema) -> MigrationPlan {
114    let mut changes = Vec::new();
115    let old_tables = by_id(&before.tables, |table| table.id.as_str());
116    let new_tables = by_id(&after.tables, |table| table.id.as_str());
117    for table in &after.tables {
118        match old_tables.get(table.id.as_str()) {
119            None => changes.push(planned(
120                SchemaChange::AddTable {
121                    table: table.clone(),
122                },
123                safe(),
124            )),
125            Some(previous) => {
126                if previous.name != table.name {
127                    changes.push(planned(
128                        SchemaChange::RenameTable {
129                            before: (*previous).clone(),
130                            after: table.clone(),
131                        },
132                        requires_input(),
133                    ));
134                }
135                diff_columns(previous, table, &mut changes);
136            }
137        }
138    }
139    for table in &before.tables {
140        if !new_tables.contains_key(table.id.as_str()) {
141            changes.push(planned(
142                SchemaChange::RemoveTable {
143                    table: table.clone(),
144                },
145                destructive(),
146            ));
147        }
148    }
149    diff_unique_constraints(before, after, &old_tables, &mut changes);
150    diff_indexes(before, after, &old_tables, &mut changes);
151    diff_seeds(before, after, &mut changes);
152    diff_foreign_keys(before, after, &old_tables, &mut changes);
153    MigrationPlan { changes }
154}
155
156fn diff_unique_constraints(
157    before: &DatabaseSchema,
158    after: &DatabaseSchema,
159    old_tables: &BTreeMap<&str, &TableSchema>,
160    changes: &mut Vec<PlannedChange>,
161) {
162    let old = by_id(&before.unique_constraints, |constraint| {
163        constraint.id.as_str()
164    });
165    let new = by_id(&after.unique_constraints, |constraint| {
166        constraint.id.as_str()
167    });
168    for constraint in &after.unique_constraints {
169        match old.get(constraint.id.as_str()) {
170            None => changes.push(planned(
171                SchemaChange::AddUniqueConstraint {
172                    constraint: constraint.clone(),
173                },
174                if after.tables.iter().any(|table| {
175                    table.name == constraint.table && !old_tables.contains_key(table.id.as_str())
176                }) {
177                    safe()
178                } else {
179                    may_lock()
180                },
181            )),
182            Some(previous) if *previous != constraint => {
183                changes.push(planned(
184                    SchemaChange::RemoveUniqueConstraint {
185                        constraint: (*previous).clone(),
186                    },
187                    destructive(),
188                ));
189                changes.push(planned(
190                    SchemaChange::AddUniqueConstraint {
191                        constraint: constraint.clone(),
192                    },
193                    may_lock(),
194                ));
195            }
196            Some(_) => {}
197        }
198    }
199    for constraint in &before.unique_constraints {
200        if !new.contains_key(constraint.id.as_str()) {
201            changes.push(planned(
202                SchemaChange::RemoveUniqueConstraint {
203                    constraint: constraint.clone(),
204                },
205                destructive(),
206            ));
207        }
208    }
209}
210
211fn diff_columns(before: &TableSchema, after: &TableSchema, changes: &mut Vec<PlannedChange>) {
212    let old_columns = by_id(&before.columns, |column| column.id.as_str());
213    let new_columns = by_id(&after.columns, |column| column.id.as_str());
214    for column in &after.columns {
215        match old_columns.get(column.id.as_str()) {
216            None => changes.push(planned(
217                SchemaChange::AddColumn {
218                    table: after.name.clone(),
219                    column: column.clone(),
220                },
221                added_column_risk(column),
222            )),
223            Some(previous) if *previous != column => changes.push(planned(
224                SchemaChange::AlterColumn {
225                    table: after.name.clone(),
226                    before: (*previous).clone(),
227                    after: column.clone(),
228                },
229                altered_column_risk(previous, column),
230            )),
231            Some(_) => {}
232        }
233    }
234    for column in &before.columns {
235        if !new_columns.contains_key(column.id.as_str()) {
236            changes.push(planned(
237                SchemaChange::RemoveColumn {
238                    table: before.name.clone(),
239                    column: column.clone(),
240                },
241                destructive(),
242            ));
243        }
244    }
245}
246
247fn diff_foreign_keys(
248    before: &DatabaseSchema,
249    after: &DatabaseSchema,
250    old_tables: &BTreeMap<&str, &TableSchema>,
251    changes: &mut Vec<PlannedChange>,
252) {
253    let old = by_id(&before.foreign_keys, |foreign_key| foreign_key.id.as_str());
254    let new = by_id(&after.foreign_keys, |foreign_key| foreign_key.id.as_str());
255    for foreign_key in &after.foreign_keys {
256        match old.get(foreign_key.id.as_str()) {
257            None => changes.push(planned(
258                SchemaChange::AddForeignKey {
259                    foreign_key: foreign_key.clone(),
260                },
261                if after.tables.iter().any(|table| {
262                    table.name == foreign_key.source_table
263                        && !old_tables.contains_key(table.id.as_str())
264                }) {
265                    safe()
266                } else {
267                    may_lock()
268                },
269            )),
270            Some(previous) if *previous != foreign_key => {
271                changes.push(planned(
272                    SchemaChange::RemoveForeignKey {
273                        foreign_key: (*previous).clone(),
274                    },
275                    destructive(),
276                ));
277                changes.push(planned(
278                    SchemaChange::AddForeignKey {
279                        foreign_key: foreign_key.clone(),
280                    },
281                    safe(),
282                ));
283            }
284            Some(_) => {}
285        }
286    }
287    for foreign_key in &before.foreign_keys {
288        if !new.contains_key(foreign_key.id.as_str()) {
289            changes.push(planned(
290                SchemaChange::RemoveForeignKey {
291                    foreign_key: foreign_key.clone(),
292                },
293                destructive(),
294            ));
295        }
296    }
297}
298
299fn added_column_risk(column: &ColumnSchema) -> ChangeRisk {
300    if column.unique {
301        return ChangeRisk {
302            schema: SchemaRisk::NonDestructive,
303            execution: ExecutionRisk::ManualReview,
304        };
305    }
306    if column.nullable {
307        safe()
308    } else {
309        ChangeRisk {
310            schema: SchemaRisk::RequiresInput,
311            execution: ExecutionRisk::MayLock,
312        }
313    }
314}
315
316fn altered_column_risk(before: &ColumnSchema, after: &ColumnSchema) -> ChangeRisk {
317    if before.name != after.name || before.nullable && !after.nullable {
318        return requires_input();
319    }
320    if before.data_type != after.data_type
321        || before.primary_key != after.primary_key
322        || before.unique != after.unique
323    {
324        return destructive();
325    }
326    if before.generated != after.generated {
327        return ChangeRisk {
328            schema: SchemaRisk::RequiresInput,
329            execution: ExecutionRisk::ManualReview,
330        };
331    }
332    safe()
333}
334
335pub(super) fn by_id<T, F>(items: &[T], id: F) -> BTreeMap<&str, &T>
336where
337    F: Fn(&T) -> &str,
338{
339    items.iter().map(|item| (id(item), item)).collect()
340}
341
342pub(super) fn planned(change: SchemaChange, risk: ChangeRisk) -> PlannedChange {
343    PlannedChange { change, risk }
344}
345
346pub(super) const fn safe() -> ChangeRisk {
347    ChangeRisk {
348        schema: SchemaRisk::NonDestructive,
349        execution: ExecutionRisk::Online,
350    }
351}
352
353pub(super) const fn may_lock() -> ChangeRisk {
354    ChangeRisk {
355        schema: SchemaRisk::NonDestructive,
356        execution: ExecutionRisk::MayLock,
357    }
358}
359
360pub(super) const fn requires_input() -> ChangeRisk {
361    ChangeRisk {
362        schema: SchemaRisk::RequiresInput,
363        execution: ExecutionRisk::MayLock,
364    }
365}
366
367pub(super) const fn destructive() -> ChangeRisk {
368    ChangeRisk {
369        schema: SchemaRisk::Destructive,
370        execution: ExecutionRisk::ManualReview,
371    }
372}