toasty-core 0.7.0

Core types, schema representations, and driver interface for Toasty
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! Schema-diff types.
//!
//! Compares two [`db::Schema`](super::db::Schema) versions and produces
//! structured changes consumed by drivers to generate migrations.
//!
//! # Examples
//!
//! ```ignore
//! use toasty_core::schema::{db, diff};
//!
//! let previous = db::Schema::default();
//! let next = db::Schema::default();
//! let hints = diff::RenameHints::new();
//! let d = diff::Schema::from(&previous, &next, &hints);
//! assert!(d.is_empty());
//! ```

mod column;
mod index;
mod schema;
mod table;
mod ty;

pub use column::Column;
pub use index::Index;
pub use schema::Schema;
pub use table::Table;
pub use ty::Type;

use hashbrown::HashMap;

use crate::schema::db::{ColumnId, IndexId, Schema as DbSchema, TableId};

/// Hints that tell the diff algorithm which schema items were renamed.
///
/// Without rename hints, a renamed table/column/index appears as a drop
/// followed by a create. Adding a hint maps the old ID to the new ID so
/// the diff produces an alter instead.
///
/// # Examples
///
/// ```ignore
/// use toasty_core::schema::{db::TableId, diff};
///
/// let mut hints = diff::RenameHints::new();
/// hints.add_table_hint(TableId(0), TableId(1));
/// assert_eq!(hints.get_table(TableId(0)), Some(TableId(1)));
/// assert_eq!(hints.get_table(TableId(2)), None);
/// ```
#[derive(Default)]
pub struct RenameHints {
    tables: HashMap<TableId, TableId>,
    columns: HashMap<ColumnId, ColumnId>,
    indices: HashMap<IndexId, IndexId>,
}

impl RenameHints {
    /// Creates an empty set of rename hints.
    pub fn new() -> Self {
        Self::default()
    }

    /// Records that the table previously identified by `from` is now identified by `to`.
    pub fn add_table_hint(&mut self, from: TableId, to: TableId) {
        self.tables.insert(from, to);
    }

    /// Records that the column previously identified by `from` is now identified by `to`.
    pub fn add_column_hint(&mut self, from: ColumnId, to: ColumnId) {
        self.columns.insert(from, to);
    }

    /// Records that the index previously identified by `from` is now identified by `to`.
    pub fn add_index_hint(&mut self, from: IndexId, to: IndexId) {
        self.indices.insert(from, to);
    }

    /// Returns the new [`TableId`] if a rename hint exists for `from`.
    pub fn get_table(&self, from: TableId) -> Option<TableId> {
        self.tables.get(&from).copied()
    }

    /// Returns the new [`ColumnId`] if a rename hint exists for `from`.
    pub fn get_column(&self, from: ColumnId) -> Option<ColumnId> {
        self.columns.get(&from).copied()
    }

    /// Returns the new [`IndexId`] if a rename hint exists for `from`.
    pub fn get_index(&self, from: IndexId) -> Option<IndexId> {
        self.indices.get(&from).copied()
    }
}

/// Shared context passed to all diff computations.
///
/// Holds references to both the previous and next [`db::Schema`](super::db::Schema)
/// versions and the [`RenameHints`] that guide rename detection.
///
/// # Examples
///
/// ```ignore
/// use toasty_core::schema::{db, diff};
///
/// let previous = db::Schema::default();
/// let next = db::Schema::default();
/// let hints = diff::RenameHints::new();
/// let cx = diff::Context::new(&previous, &next, &hints);
/// assert!(cx.previous().tables.is_empty());
/// ```
pub struct Context<'a> {
    previous: &'a DbSchema,
    next: &'a DbSchema,

    rename_hints: &'a RenameHints,
}

impl<'a> Context<'a> {
    /// Creates a new diff context from the previous schema, the next schema,
    /// and the rename hints that map old IDs to new IDs.
    pub fn new(previous: &'a DbSchema, next: &'a DbSchema, rename_hints: &'a RenameHints) -> Self {
        Self {
            previous,
            next,
            rename_hints,
        }
    }

    /// Returns the rename hints for this diff.
    pub fn rename_hints(&self) -> &'a RenameHints {
        self.rename_hints
    }

    /// Returns the schema before the change.
    pub fn previous(&self) -> &'a DbSchema {
        self.previous
    }

    /// Returns the schema after the change.
    pub fn next(&self) -> &'a DbSchema {
        self.next
    }
}