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}