Skip to main content

schema_parser/parser/
parser.rs

1use crate::parse_database_roxml;
2use crate::parser::convert::convert_database;
3use crate::parser::nodes::DatabaseXml;
4use schema_model::model::database_model::DatabaseModel;
5
6/// parse a string containing XML into a DatabaseModel.
7pub fn parse_database_xml(xml: &str) -> Result<DatabaseModel, String> {
8    let database_xml: DatabaseXml = parse_database_roxml(xml).map_err(|e| format!("XML parse error: {e}"))?;
9    convert_database(database_xml)
10
11    // let database_xml: DatabaseXml = qx_from_str(xml).map_err(|e| format!("XML parse error: {e}"))?;
12    // Ok(convert_database(database_xml))
13}
14
15#[cfg(test)]
16mod tests {
17    use super::*;
18    use std::fs;
19
20    #[test]
21    fn parse_test_resource_schema() {
22        let xml = fs::read_to_string("tests/resources/schema-parser-test-schema.xml")
23            .expect("resource present");
24        let database = parse_database_xml(xml.as_str()).expect("parse ok");
25        let schemas = database.schemas();
26        assert_eq!(schemas.len(), 2);
27        let default_schema = &schemas[0];
28        // Expect at least 3 tables shown in the sample
29        assert!(default_schema.tables().len() >= 3);
30
31        let parent = default_schema.get_table("ParentTable");
32        assert_eq!(parent.columns().len(), 4);
33        assert!(parent.primary_key().is_some());
34
35        let child = default_schema.get_table("ChildTable");
36        assert_eq!(child.columns().len(), 3);
37        assert!(child.primary_key().is_some());
38
39        let tester = default_schema.get_table("ColumnTesterTable");
40        assert!(tester.has_column("varchar"));
41        assert!(tester.has_column("sequence"));
42    }
43
44    fn wrap(inner: &str) -> String {
45        format!(
46            r#"<database xmlns="http://stano.com/database">{}</database>"#,
47            inner
48        )
49    }
50
51    #[test]
52    fn dangling_relation_target_returns_error_instead_of_panicking() {
53        let xml = wrap(
54            r#"
55            <table name="Child">
56                <columns>
57                    <column name="ParentId" type="int" required="true"/>
58                </columns>
59                <relations>
60                    <relation src="ParentId" table="Regoin" column="Id" type="cascade"/>
61                </relations>
62            </table>
63            "#,
64        );
65
66        let result = parse_database_xml(&xml);
67
68        assert!(result.is_err());
69        assert!(result.unwrap_err().contains("Regoin"));
70    }
71
72    #[test]
73    fn reverse_relation_resolves_child_in_a_different_named_schema() {
74        // The child ("sales.order_item") lives in a non-default schema and references a
75        // parent ("product") in the default schema. The reverse relation attached to
76        // "product" must be able to resolve "sales.order_item" back - not just "order_item"
77        // unqualified, which would incorrectly look for it in the default schema.
78        let xml = wrap(
79            r#"
80            <table name="Product">
81                <columns>
82                    <column name="Id" type="sequence" required="true"/>
83                </columns>
84                <keys>
85                    <primary>
86                        <column name="Id"/>
87                    </primary>
88                </keys>
89            </table>
90            <schema name="sales">
91                <table name="OrderItem">
92                    <columns>
93                        <column name="ProductId" type="int" required="true"/>
94                    </columns>
95                    <relations>
96                        <relation src="ProductId" table="Product" column="Id" type="cascade"/>
97                    </relations>
98                </table>
99            </schema>
100            "#,
101        );
102
103        let database = parse_database_xml(&xml).expect("parse ok");
104
105        let default_schema = database.schemas().iter().find(|s| s.schema_name().is_none()).unwrap();
106        let product = default_schema.get_table("Product");
107        let reverse_relations = product.reverse_relations();
108        assert_eq!(reverse_relations.len(), 1);
109        assert_eq!(reverse_relations[0].from_table_name(), "sales.OrderItem");
110    }
111
112    #[test]
113    fn function_with_unrecognized_database_type_returns_error_instead_of_vanishing() {
114        let xml = wrap(
115            r#"
116            <function name="my_func">
117                <sql databaseType="postgres">select 1</sql>
118            </function>
119            "#,
120        );
121
122        let result = parse_database_xml(&xml);
123
124        assert!(result.is_err());
125        let err = result.unwrap_err();
126        assert!(err.contains("my_func"));
127        assert!(err.contains("postgres"));
128    }
129
130    #[test]
131    fn constraint_with_missing_database_type_returns_error_instead_of_vanishing() {
132        let xml = wrap(
133            r#"
134            <table name="Widget">
135                <columns>
136                    <column name="Id" type="int"/>
137                </columns>
138                <constraints>
139                    <constraint name="ck_id">check (Id > 0)</constraint>
140                </constraints>
141            </table>
142            "#,
143        );
144
145        let result = parse_database_xml(&xml);
146
147        assert!(result.is_err());
148        assert!(result.unwrap_err().contains("ck_id"));
149    }
150
151    #[test]
152    fn view_with_unrecognized_database_type_returns_error_instead_of_silently_applying_to_all() {
153        let xml = wrap(
154            r#"
155            <view name="my_view" databaseType="postgres">select 1</view>
156            "#,
157        );
158
159        let result = parse_database_xml(&xml);
160
161        assert!(result.is_err());
162        let err = result.unwrap_err();
163        assert!(err.contains("my_view"));
164        assert!(err.contains("postgres"));
165    }
166
167    #[test]
168    fn view_with_no_database_type_still_parses_and_applies_to_every_database() {
169        let xml = wrap(
170            r#"
171            <view name="my_view">select 1</view>
172            "#,
173        );
174
175        let database = parse_database_xml(&xml).expect("parse ok");
176        let view = &database.default_schema().all_views()[0];
177        assert_eq!(view.database_type(), None);
178    }
179
180    #[test]
181    fn missing_required_table_name_returns_error_instead_of_defaulting_to_empty_string() {
182        let xml = wrap(
183            r#"
184            <table>
185                <columns>
186                    <column name="Id" type="int"/>
187                </columns>
188            </table>
189            "#,
190        );
191
192        let result = parse_database_xml(&xml);
193
194        assert!(result.is_err());
195        let err = result.unwrap_err();
196        assert!(err.contains("table"));
197        assert!(err.contains("name"));
198    }
199
200    #[test]
201    fn unrecognized_relation_type_returns_error_instead_of_defaulting_to_enforce() {
202        let xml = wrap(
203            r#"
204            <table name="Child">
205                <columns>
206                    <column name="ParentId" type="int" required="true"/>
207                </columns>
208                <relations>
209                    <relation src="ParentId" table="Parent" column="Id" type="cascde"/>
210                </relations>
211            </table>
212            <table name="Parent">
213                <columns>
214                    <column name="Id" type="int" required="true"/>
215                </columns>
216            </table>
217            "#,
218        );
219
220        let result = parse_database_xml(&xml);
221
222        assert!(result.is_err());
223        let err = result.unwrap_err();
224        assert!(err.contains("cascde"));
225    }
226
227    #[test]
228    fn unrecognized_lock_escalation_returns_error_instead_of_defaulting_to_auto() {
229        let xml = wrap(
230            r#"
231            <table name="Widget" lockEscalation="sometimes">
232                <columns>
233                    <column name="Id" type="int"/>
234                </columns>
235            </table>
236            "#,
237        );
238
239        let result = parse_database_xml(&xml);
240
241        assert!(result.is_err());
242        assert!(result.unwrap_err().contains("sometimes"));
243    }
244
245    #[test]
246    fn unrecognized_other_sql_order_returns_error_instead_of_defaulting_to_top() {
247        let xml = wrap(
248            r#"
249            <otherSql databaseType="postgresql" order="middle">select 1</otherSql>
250            "#,
251        );
252
253        let result = parse_database_xml(&xml);
254
255        assert!(result.is_err());
256        assert!(result.unwrap_err().contains("middle"));
257    }
258
259    #[test]
260    fn unrecognized_aggregation_frequency_returns_error_instead_of_defaulting_to_monthly() {
261        let xml = wrap(
262            r#"
263            <table name="Widget">
264                <columns>
265                    <column name="Id" type="int"/>
266                    <column name="Amount" type="int"/>
267                </columns>
268                <aggregations>
269                    <aggregate destinationTable="WidgetAgg" dateColumn="Id" timestampColumn="Id" frequency="fortnightly">
270                        <sum sourceColumn="Amount" destinationColumn="TotalAmount"/>
271                        <group>
272                            <column source="Id" destination="Id"/>
273                        </group>
274                    </aggregate>
275                </aggregations>
276            </table>
277            "#,
278        );
279
280        let result = parse_database_xml(&xml);
281
282        assert!(result.is_err());
283        assert!(result.unwrap_err().contains("fortnightly"));
284    }
285
286    #[test]
287    fn invalid_column_type_returns_error_instead_of_panicking() {
288        let xml = wrap(
289            r#"
290            <table name="Widget">
291                <columns>
292                    <column name="Name" type="varchr"/>
293                </columns>
294            </table>
295            "#,
296        );
297
298        let result = parse_database_xml(&xml);
299
300        assert!(result.is_err());
301        let err = result.unwrap_err();
302        assert!(err.contains("Widget"));
303        assert!(err.contains("Name"));
304    }
305}