rjango 0.1.1

A full-stack Rust backend framework inspired by Django
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

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DatabaseFeatures {
    pub supports_transactions: bool,
    pub supports_savepoints: bool,
    pub supports_partial_indexes: bool,
    pub supports_json_field: bool,
    pub supports_foreign_keys: bool,
    pub supports_check_constraints: bool,
    pub supports_sequence_reset: bool,
    pub can_introspect_json_field: bool,
    pub has_bulk_insert: bool,
    pub supports_tablespaces: bool,
    pub supports_column_check_constraints: bool,
    pub supports_expression_indexes: bool,
    pub uses_savepoints: bool,
}

impl DatabaseFeatures {
    #[must_use]
    pub fn sqlite() -> Self {
        Self {
            supports_transactions: true,
            supports_savepoints: true,
            supports_partial_indexes: true,
            supports_json_field: true,
            supports_foreign_keys: true,
            supports_check_constraints: true,
            supports_sequence_reset: true,
            can_introspect_json_field: false,
            has_bulk_insert: true,
            supports_tablespaces: false,
            supports_column_check_constraints: false,
            supports_expression_indexes: true,
            uses_savepoints: true,
        }
    }

    #[must_use]
    pub fn postgresql() -> Self {
        Self {
            supports_transactions: true,
            supports_savepoints: true,
            supports_partial_indexes: true,
            supports_json_field: true,
            supports_foreign_keys: true,
            supports_check_constraints: true,
            supports_sequence_reset: true,
            can_introspect_json_field: true,
            has_bulk_insert: true,
            supports_tablespaces: true,
            supports_column_check_constraints: true,
            supports_expression_indexes: true,
            uses_savepoints: true,
        }
    }

    #[must_use]
    pub fn mysql() -> Self {
        Self {
            supports_transactions: true,
            supports_savepoints: true,
            supports_partial_indexes: false,
            supports_json_field: true,
            supports_foreign_keys: true,
            supports_check_constraints: true,
            supports_sequence_reset: true,
            can_introspect_json_field: true,
            has_bulk_insert: true,
            supports_tablespaces: true,
            supports_column_check_constraints: true,
            supports_expression_indexes: true,
            uses_savepoints: true,
        }
    }
}

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

    #[test]
    fn sqlite_features_match_expected_capabilities() {
        let features = DatabaseFeatures::sqlite();

        assert!(features.supports_transactions);
        assert!(features.supports_partial_indexes);
        assert!(features.supports_expression_indexes);
        assert!(!features.supports_tablespaces);
        assert!(!features.can_introspect_json_field);
        assert!(!features.supports_column_check_constraints);
    }

    #[test]
    fn postgresql_features_match_expected_capabilities() {
        let features = DatabaseFeatures::postgresql();

        assert!(features.supports_transactions);
        assert!(features.supports_savepoints);
        assert!(features.supports_partial_indexes);
        assert!(features.supports_tablespaces);
        assert!(features.can_introspect_json_field);
        assert!(features.supports_expression_indexes);
    }

    #[test]
    fn mysql_features_match_expected_capabilities() {
        let features = DatabaseFeatures::mysql();

        assert!(features.supports_transactions);
        assert!(features.supports_savepoints);
        assert!(!features.supports_partial_indexes);
        assert!(features.supports_json_field);
        assert!(features.supports_tablespaces);
        assert!(features.supports_column_check_constraints);
    }

    #[test]
    fn backend_feature_profiles_differ_where_expected() {
        let sqlite = DatabaseFeatures::sqlite();
        let postgres = DatabaseFeatures::postgresql();
        let mysql = DatabaseFeatures::mysql();

        assert_ne!(sqlite, postgres);
        assert_ne!(sqlite, mysql);
        assert_ne!(
            postgres.supports_partial_indexes,
            mysql.supports_partial_indexes
        );
    }
}