toasty-core 0.2.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
143
144
145
146
147
148
149
150

use super::{
    Column, ColumnId, DiffContext, Index, IndexId, RenameHints, Table, TableId, TablesDiff,
};

/// The complete database-level schema: a collection of tables.
///
/// Provides indexed access to tables, columns, and indices by their IDs.
///
/// # Examples
///
/// ```ignore
/// use toasty_core::schema::db::Schema;
///
/// let schema = Schema::default();
/// assert!(schema.tables.is_empty());
/// ```
#[derive(Debug, Default, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Schema {
    /// All tables in this schema.
    pub tables: Vec<Table>,
}

impl Schema {
    /// Returns the column identified by `id`.
    ///
    /// # Panics
    ///
    /// Panics if the table or column index is out of bounds.
    pub fn column(&self, id: impl Into<ColumnId>) -> &Column {
        let id = id.into();
        self.table(id.table)
            .columns
            .get(id.index)
            .expect("invalid column ID")
    }

    /// Returns a mutable reference to the column identified by `id`.
    ///
    /// # Panics
    ///
    /// Panics if the table or column index is out of bounds.
    pub fn column_mut(&mut self, id: impl Into<ColumnId>) -> &mut Column {
        let id = id.into();
        self.table_mut(id.table)
            .columns
            .get_mut(id.index)
            .expect("invalid column ID")
    }

    /// Returns the index identified by `id`.
    ///
    /// # Panics
    ///
    /// Panics if the table or index offset is out of bounds.
    // NOTE: this is unlikely to confuse users given the context.
    #[allow(clippy::should_implement_trait)]
    pub fn index(&self, id: IndexId) -> &Index {
        self.table(id.table)
            .indices
            .get(id.index)
            .expect("invalid index ID")
    }

    /// Returns a mutable reference to the index identified by `id`.
    ///
    /// # Panics
    ///
    /// Panics if the table or index offset is out of bounds.
    // NOTE: this is unlikely to confuse users given the context.
    #[allow(clippy::should_implement_trait)]
    pub fn index_mut(&mut self, id: IndexId) -> &mut Index {
        self.table_mut(id.table)
            .indices
            .get_mut(id.index)
            .expect("invalid index ID")
    }

    /// Returns the table identified by `id`.
    ///
    /// # Panics
    ///
    /// Panics if the table index is out of bounds.
    pub fn table(&self, id: impl Into<TableId>) -> &Table {
        self.tables.get(id.into().0).expect("invalid table ID")
    }

    /// Returns a mutable reference to the table identified by `id`.
    ///
    /// # Panics
    ///
    /// Panics if the table index is out of bounds.
    pub fn table_mut(&mut self, id: impl Into<TableId>) -> &mut Table {
        self.tables.get_mut(id.into().0).expect("invalid table ID")
    }
}

/// The top-level diff between two database schemas.
///
/// Contains a [`TablesDiff`] describing created, dropped, and altered tables.
/// Constructed via [`SchemaDiff::from`].
///
/// # Examples
///
/// ```ignore
/// use toasty_core::schema::db::{SchemaDiff, RenameHints, Schema};
///
/// let previous = Schema::default();
/// let next = Schema::default();
/// let hints = RenameHints::new();
/// let diff = SchemaDiff::from(&previous, &next, &hints);
/// assert!(diff.is_empty());
/// ```
pub struct SchemaDiff<'a> {
    previous: &'a Schema,
    next: &'a Schema,
    tables: TablesDiff<'a>,
}

impl<'a> SchemaDiff<'a> {
    /// Computes the diff between two schemas, using the provided rename hints.
    pub fn from(from: &'a Schema, to: &'a Schema, rename_hints: &'a RenameHints) -> Self {
        let cx = &DiffContext::new(from, to, rename_hints);
        Self {
            previous: from,
            next: to,
            tables: TablesDiff::from(cx, &from.tables, &to.tables),
        }
    }

    /// Returns the table-level diff.
    pub fn tables(&self) -> &TablesDiff<'a> {
        &self.tables
    }

    /// Returns `true` if no tables were created, dropped, or altered.
    pub fn is_empty(&self) -> bool {
        self.tables.is_empty()
    }

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

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