pgmt 0.5.0

PostgreSQL migration tool that keeps your schema files as the source of truth
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

//! SQL rendering for schema operations

use crate::catalog::id::DbObjectId;
use crate::diff::operations::SchemaOperation;
use crate::render::{RenderedSql, Safety, SqlRenderer, quote_ident};

impl SqlRenderer for SchemaOperation {
    fn to_sql(&self) -> Vec<RenderedSql> {
        match self {
            SchemaOperation::Create { name } => vec![RenderedSql {
                // IF NOT EXISTS: shadow images can provide schemas (PostGIS's
                // topology, Supabase's auth) that survive the template reset
                // and may also appear in managed schema files.
                sql: format!("CREATE SCHEMA IF NOT EXISTS {};", quote_ident(name)),
                safety: Safety::Safe,
            }],
            SchemaOperation::Drop { name } => vec![RenderedSql {
                sql: format!("DROP SCHEMA {};", quote_ident(name)),
                safety: Safety::Safe,
            }],
        }
    }

    fn db_object_id(&self) -> DbObjectId {
        match self {
            SchemaOperation::Create { name } | SchemaOperation::Drop { name } => {
                DbObjectId::Schema { name: name.clone() }
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_render_create_schema() {
        let op = SchemaOperation::Create {
            name: "app".to_string(),
        };
        let rendered = op.to_sql();
        assert_eq!(rendered.len(), 1);
        assert_eq!(rendered[0].sql, "CREATE SCHEMA IF NOT EXISTS \"app\";");
        assert_eq!(rendered[0].safety, Safety::Safe);
    }

    #[test]
    fn test_render_create_schema_with_special_chars() {
        let op = SchemaOperation::Create {
            name: "my-schema".to_string(),
        };
        let rendered = op.to_sql();
        assert_eq!(
            rendered[0].sql,
            "CREATE SCHEMA IF NOT EXISTS \"my-schema\";"
        );
    }

    #[test]
    fn test_render_drop_schema() {
        let op = SchemaOperation::Drop {
            name: "old_schema".to_string(),
        };
        let rendered = op.to_sql();
        assert_eq!(rendered.len(), 1);
        assert_eq!(rendered[0].sql, "DROP SCHEMA \"old_schema\";");
        assert_eq!(rendered[0].safety, Safety::Safe);
    }

    #[test]
    fn test_has_destructive_sql() {
        let create = SchemaOperation::Create {
            name: "test".to_string(),
        };
        let drop = SchemaOperation::Drop {
            name: "test".to_string(),
        };

        // DROP SCHEMA (without CASCADE) is safe - will fail if schema contains objects
        assert!(
            !create
                .to_sql()
                .iter()
                .any(|s| s.safety == Safety::Destructive)
        );
        assert!(
            !drop
                .to_sql()
                .iter()
                .any(|s| s.safety == Safety::Destructive)
        );
    }

    #[test]
    fn test_db_object_id() {
        let op = SchemaOperation::Create {
            name: "myschema".to_string(),
        };
        assert_eq!(
            op.db_object_id(),
            DbObjectId::Schema {
                name: "myschema".to_string()
            }
        );
    }
}