Skip to main content

schema_parser/parser/
xml_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 =
9        parse_database_roxml(xml).map_err(|e| format!("XML parse error: {e}"))?;
10    convert_database(database_xml)
11
12    // let database_xml: DatabaseXml = qx_from_str(xml).map_err(|e| format!("XML parse error: {e}"))?;
13    // Ok(convert_database(database_xml))
14}
15
16#[cfg(test)]
17mod tests {
18    use super::*;
19    use std::fs;
20
21    #[test]
22    fn parse_test_resource_schema() {
23        let xml = fs::read_to_string("tests/resources/schema-parser-test-schema.xml")
24            .expect("resource present");
25        let database = parse_database_xml(xml.as_str()).expect("parse ok");
26        let schemas = database.schemas();
27        assert_eq!(schemas.len(), 2);
28        let default_schema = &schemas[0];
29        // Expect at least 3 tables shown in the sample
30        assert!(default_schema.tables().len() >= 3);
31
32        let parent = default_schema.get_table("ParentTable");
33        assert_eq!(parent.columns().len(), 4);
34        assert!(parent.primary_key().is_some());
35
36        let child = default_schema.get_table("ChildTable");
37        assert_eq!(child.columns().len(), 3);
38        assert!(child.primary_key().is_some());
39
40        let tester = default_schema.get_table("ColumnTesterTable");
41        assert!(tester.has_column("varchar"));
42        assert!(tester.has_column("sequence"));
43    }
44
45    fn wrap(inner: &str) -> String {
46        format!(
47            r#"<database xmlns="http://stano.com/database">{}</database>"#,
48            inner
49        )
50    }
51
52    #[test]
53    fn dangling_relation_target_returns_error_instead_of_panicking() {
54        let xml = wrap(
55            r#"
56            <table name="Child">
57                <columns>
58                    <column name="ParentId" type="int" required="true"/>
59                </columns>
60                <relations>
61                    <relation src="ParentId" table="Regoin" column="Id" type="cascade"/>
62                </relations>
63            </table>
64            "#,
65        );
66
67        let result = parse_database_xml(&xml);
68
69        assert!(result.is_err());
70        assert!(result.unwrap_err().contains("Regoin"));
71    }
72
73    #[test]
74    fn reverse_relation_resolves_child_in_a_different_named_schema() {
75        // The child ("sales.order_item") lives in a non-default schema and references a
76        // parent ("product") in the default schema. The reverse relation attached to
77        // "product" must be able to resolve "sales.order_item" back - not just "order_item"
78        // unqualified, which would incorrectly look for it in the default schema.
79        let xml = wrap(
80            r#"
81            <table name="Product">
82                <columns>
83                    <column name="Id" type="sequence" required="true"/>
84                </columns>
85                <keys>
86                    <primary>
87                        <column name="Id"/>
88                    </primary>
89                </keys>
90            </table>
91            <schema name="sales">
92                <table name="OrderItem">
93                    <columns>
94                        <column name="ProductId" type="int" required="true"/>
95                    </columns>
96                    <relations>
97                        <relation src="ProductId" table="Product" column="Id" type="cascade"/>
98                    </relations>
99                </table>
100            </schema>
101            "#,
102        );
103
104        let database = parse_database_xml(&xml).expect("parse ok");
105
106        let default_schema = database
107            .schemas()
108            .iter()
109            .find(|s| s.schema_name().is_none())
110            .unwrap();
111        let product = default_schema.get_table("Product");
112        let reverse_relations = product.reverse_relations();
113        assert_eq!(reverse_relations.len(), 1);
114        assert_eq!(reverse_relations[0].from_table_name(), "sales.OrderItem");
115    }
116
117    #[test]
118    fn function_with_unrecognized_database_type_returns_error_instead_of_vanishing() {
119        let xml = wrap(
120            r#"
121            <function name="my_func">
122                <sql databaseType="postgres">select 1</sql>
123            </function>
124            "#,
125        );
126
127        let result = parse_database_xml(&xml);
128
129        assert!(result.is_err());
130        let err = result.unwrap_err();
131        assert!(err.contains("my_func"));
132        assert!(err.contains("postgres"));
133    }
134
135    #[test]
136    fn constraint_with_missing_database_type_returns_error_instead_of_vanishing() {
137        let xml = wrap(
138            r#"
139            <table name="Widget">
140                <columns>
141                    <column name="Id" type="int"/>
142                </columns>
143                <constraints>
144                    <constraint name="ck_id">check (Id > 0)</constraint>
145                </constraints>
146            </table>
147            "#,
148        );
149
150        let result = parse_database_xml(&xml);
151
152        assert!(result.is_err());
153        assert!(result.unwrap_err().contains("ck_id"));
154    }
155
156    #[test]
157    fn view_with_unrecognized_database_type_returns_error_instead_of_silently_applying_to_all() {
158        let xml = wrap(
159            r#"
160            <view name="my_view" databaseType="postgres">select 1</view>
161            "#,
162        );
163
164        let result = parse_database_xml(&xml);
165
166        assert!(result.is_err());
167        let err = result.unwrap_err();
168        assert!(err.contains("my_view"));
169        assert!(err.contains("postgres"));
170    }
171
172    #[test]
173    fn view_with_no_database_type_still_parses_and_applies_to_every_database() {
174        let xml = wrap(
175            r#"
176            <view name="my_view">select 1</view>
177            "#,
178        );
179
180        let database = parse_database_xml(&xml).expect("parse ok");
181        let view = &database.default_schema().all_views()[0];
182        assert_eq!(view.database_type(), None);
183    }
184
185    #[test]
186    fn missing_required_table_name_returns_error_instead_of_defaulting_to_empty_string() {
187        let xml = wrap(
188            r#"
189            <table>
190                <columns>
191                    <column name="Id" type="int"/>
192                </columns>
193            </table>
194            "#,
195        );
196
197        let result = parse_database_xml(&xml);
198
199        assert!(result.is_err());
200        let err = result.unwrap_err();
201        assert!(err.contains("table"));
202        assert!(err.contains("name"));
203    }
204
205    #[test]
206    fn unrecognized_relation_type_returns_error_instead_of_defaulting_to_enforce() {
207        let xml = wrap(
208            r#"
209            <table name="Child">
210                <columns>
211                    <column name="ParentId" type="int" required="true"/>
212                </columns>
213                <relations>
214                    <relation src="ParentId" table="Parent" column="Id" type="cascde"/>
215                </relations>
216            </table>
217            <table name="Parent">
218                <columns>
219                    <column name="Id" type="int" required="true"/>
220                </columns>
221            </table>
222            "#,
223        );
224
225        let result = parse_database_xml(&xml);
226
227        assert!(result.is_err());
228        let err = result.unwrap_err();
229        assert!(err.contains("cascde"));
230    }
231
232    #[test]
233    fn unrecognized_lock_escalation_returns_error_instead_of_defaulting_to_auto() {
234        let xml = wrap(
235            r#"
236            <table name="Widget" lockEscalation="sometimes">
237                <columns>
238                    <column name="Id" type="int"/>
239                </columns>
240            </table>
241            "#,
242        );
243
244        let result = parse_database_xml(&xml);
245
246        assert!(result.is_err());
247        assert!(result.unwrap_err().contains("sometimes"));
248    }
249
250    #[test]
251    fn unrecognized_other_sql_order_returns_error_instead_of_defaulting_to_top() {
252        let xml = wrap(
253            r#"
254            <otherSql databaseType="postgresql" order="middle">select 1</otherSql>
255            "#,
256        );
257
258        let result = parse_database_xml(&xml);
259
260        assert!(result.is_err());
261        assert!(result.unwrap_err().contains("middle"));
262    }
263
264    #[test]
265    fn unrecognized_aggregation_frequency_returns_error_instead_of_defaulting_to_monthly() {
266        let xml = wrap(
267            r#"
268            <table name="Widget">
269                <columns>
270                    <column name="Id" type="int"/>
271                    <column name="Amount" type="int"/>
272                </columns>
273                <aggregations>
274                    <aggregate destinationTable="WidgetAgg" dateColumn="Id" timestampColumn="Id" frequency="fortnightly">
275                        <sum sourceColumn="Amount" destinationColumn="TotalAmount"/>
276                        <group>
277                            <column source="Id" destination="Id"/>
278                        </group>
279                    </aggregate>
280                </aggregations>
281            </table>
282            "#,
283        );
284
285        let result = parse_database_xml(&xml);
286
287        assert!(result.is_err());
288        assert!(result.unwrap_err().contains("fortnightly"));
289    }
290
291    #[test]
292    fn invalid_column_type_returns_error_instead_of_panicking() {
293        let xml = wrap(
294            r#"
295            <table name="Widget">
296                <columns>
297                    <column name="Name" type="varchr"/>
298                </columns>
299            </table>
300            "#,
301        );
302
303        let result = parse_database_xml(&xml);
304
305        assert!(result.is_err());
306        let err = result.unwrap_err();
307        assert!(err.contains("Widget"));
308        assert!(err.contains("Name"));
309    }
310
311    #[test]
312    fn primary_key_with_where_predicate_returns_error() {
313        let xml = wrap(
314            r#"
315            <table name="Widget">
316                <columns>
317                    <column name="Id" type="int" required="true"/>
318                </columns>
319                <keys>
320                    <primary where="1=1">
321                        <column name="Id"/>
322                    </primary>
323                </keys>
324            </table>
325            "#,
326        );
327
328        let result = parse_database_xml(&xml);
329
330        assert!(result.is_err());
331        assert!(result.unwrap_err().contains("primary"));
332    }
333
334    #[test]
335    fn clustered_unique_key_with_where_predicate_returns_error() {
336        let xml = wrap(
337            r#"
338            <table name="Widget">
339                <columns>
340                    <column name="ParentId" type="int"/>
341                </columns>
342                <keys>
343                    <unique cluster="true" where="ParentId is not null">
344                        <column name="ParentId"/>
345                    </unique>
346                </keys>
347            </table>
348            "#,
349        );
350
351        let result = parse_database_xml(&xml);
352
353        assert!(result.is_err());
354        assert!(result.unwrap_err().contains("clustered"));
355    }
356
357    #[test]
358    fn unique_key_with_where_predicate_is_promoted_to_a_filtered_unique_index() {
359        let xml = wrap(
360            r#"
361            <table name="Widget">
362                <columns>
363                    <column name="ParentId" type="int"/>
364                </columns>
365                <keys>
366                    <unique where="ParentId is not null">
367                        <column name="ParentId"/>
368                    </unique>
369                </keys>
370            </table>
371            "#,
372        );
373
374        let database = parse_database_xml(&xml).expect("parse ok");
375        let schema = &database.schemas()[0];
376        let table = schema.get_table("Widget");
377
378        assert!(table.keys().is_empty());
379        assert_eq!(table.indexes().len(), 1);
380        let index = &table.indexes()[0];
381        assert!(index.is_unique());
382        assert_eq!(index.filter(), Some("ParentId is not null"));
383    }
384
385    #[test]
386    fn index_where_predicate_is_parsed() {
387        let xml = wrap(
388            r#"
389            <table name="Widget">
390                <columns>
391                    <column name="ParentId" type="int"/>
392                </columns>
393                <keys>
394                    <index unique="true" where="ParentId is not null">
395                        <column name="ParentId"/>
396                    </index>
397                </keys>
398            </table>
399            "#,
400        );
401
402        let database = parse_database_xml(&xml).expect("parse ok");
403        let schema = &database.schemas()[0];
404        let table = schema.get_table("Widget");
405
406        assert_eq!(table.indexes().len(), 1);
407        let index = &table.indexes()[0];
408        assert!(index.is_unique());
409        assert_eq!(index.filter(), Some("ParentId is not null"));
410    }
411}