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 schema_model::model::aggregation::AggregationType;
20    use std::fs;
21
22    #[test]
23    fn parse_test_resource_schema() {
24        let xml = fs::read_to_string("tests/resources/schema-parser-test-schema.xml")
25            .expect("resource present");
26        let database = parse_database_xml(xml.as_str()).expect("parse ok");
27        let schemas = database.schemas();
28        assert_eq!(schemas.len(), 2);
29        let default_schema = &schemas[0];
30        // Expect at least 3 tables shown in the sample
31        assert!(default_schema.tables().len() >= 3);
32
33        let parent = default_schema.get_table("ParentTable");
34        assert_eq!(parent.columns().len(), 4);
35        assert!(parent.primary_key().is_some());
36
37        let child = default_schema.get_table("ChildTable");
38        assert_eq!(child.columns().len(), 3);
39        assert!(child.primary_key().is_some());
40
41        let tester = default_schema.get_table("ColumnTesterTable");
42        assert!(tester.has_column("varchar"));
43        assert!(tester.has_column("sequence"));
44    }
45
46    fn wrap(inner: &str) -> String {
47        format!(
48            r#"<database xmlns="http://stano.com/database">{}</database>"#,
49            inner
50        )
51    }
52
53    #[test]
54    fn database_specific_checks_are_kept_per_database() {
55        use schema_model::model::types::DatabaseType;
56        let xml = wrap(
57            r#"
58            <table name="Widget">
59                <columns>
60                    <column name="Qty" type="int">
61                        <check>Qty &gt; 0</check>
62                        <check databaseType="postgresql">Qty &gt; 100</check>
63                        <check databaseType="h2">Qty &gt; 999</check>
64                    </column>
65                </columns>
66            </table>"#,
67        );
68        let database = parse_database_xml(&xml).expect("parse ok");
69        let qty = database
70            .default_schema()
71            .get_table("Widget")
72            .column("Qty")
73            .clone();
74
75        assert_eq!(qty.check_constraint(), Some("Qty > 0"));
76        assert_eq!(
77            qty.check_constraint_for(DatabaseType::Postgresql),
78            Some("Qty > 100")
79        );
80        assert_eq!(
81            qty.check_constraint_for(DatabaseType::SqlServer),
82            Some("Qty > 0")
83        );
84        // h2 is not a database this library generates for, so that check is dropped.
85        assert_eq!(qty.database_checks().len(), 1);
86    }
87
88    fn parse_err(inner: &str) -> String {
89        match parse_database_xml(&wrap(inner)) {
90            Ok(_) => panic!("expected a parse error"),
91            Err(e) => e,
92        }
93    }
94
95    #[test]
96    fn h2_targeted_elements_are_accepted_and_dropped() {
97        use schema_model::model::types::DatabaseType;
98        let xml = wrap(
99            r#"
100            <table name="T">
101                <columns><column name="A" type="int"><check databaseType="h2">A &gt; 0</check></column></columns>
102                <triggers>
103                    <update databaseType="h2">select 1;</update>
104                    <update databaseType="sqlite">select 2;</update>
105                </triggers>
106                <constraints>
107                    <constraint name="CK_H2" databaseType="h2">A &lt; 9</constraint>
108                    <constraint name="CK_PG" databaseType="postgresql">A &lt; 9</constraint>
109                </constraints>
110                <initialData>
111                    <sql databaseType="h2">insert into t values (1);</sql>
112                    <sql>insert into t values (2);</sql>
113                </initialData>
114            </table>
115            <view name="V" databaseType="h2">select 1</view>
116            <view name="W">select 1</view>
117            <function name="F"><sql databaseType="h2">x</sql></function>
118            <procedure name="P"><sql databaseType="h2">x</sql><sql databaseType="sqlite">y</sql></procedure>
119            <otherSql databaseType="h2" order="top">select 1</otherSql>"#,
120        );
121        let database = parse_database_xml(&xml).expect("h2 elements parse");
122        let schema = database.default_schema();
123        let table = schema.get_table("T");
124        assert_eq!(table.triggers().len(), 1);
125        assert_eq!(table.constraints().len(), 1);
126        assert_eq!(table.initial_data().len(), 1);
127        assert_eq!(schema.views(DatabaseType::Postgresql).len(), 1);
128        assert!(schema.functions().is_empty());
129        assert_eq!(schema.procedures().len(), 1);
130        assert!(schema.other_sql().is_empty());
131    }
132
133    #[test]
134    fn constraint_without_database_type_applies_to_every_database() {
135        let xml = wrap(
136            r#"<table name="T"><columns><column name="A" type="int"/></columns>
137            <constraints><constraint name="CK">A &gt; 0</constraint></constraints></table>"#,
138        );
139        let database = parse_database_xml(&xml).expect("parse ok");
140        let constraints = database
141            .default_schema()
142            .get_table("T")
143            .constraints()
144            .to_vec();
145        assert_eq!(constraints.len(), 1);
146        assert_eq!(constraints[0].database_type(), None);
147    }
148
149    #[test]
150    fn unknown_database_type_is_still_rejected() {
151        let err = parse_err(
152            r#"<table name="T"><columns><column name="A" type="int"/></columns><constraints><constraint name="C" databaseType="oracle">x</constraint></constraints></table>"#,
153        );
154        assert!(err.contains("unrecognized databaseType 'oracle'"), "{err}");
155        let err = parse_err(
156            r#"<table name="T"><columns><column name="A" type="int"><check databaseType="oracle">x</check></column></columns></table>"#,
157        );
158        assert!(err.contains("unrecognized databaseType 'oracle'"), "{err}");
159    }
160
161    #[test]
162    fn negative_scale_or_length_is_rejected() {
163        let err = parse_err(
164            r#"<table name="T"><columns><column name="A" type="decimal" length="10" scale="-2"/></columns></table>"#,
165        );
166        assert!(err.contains("scale") && err.contains("negative"), "{err}");
167        let err = parse_err(
168            r#"<table name="T"><columns><column name="A" type="varchar" length="-1"/></columns></table>"#,
169        );
170        assert!(err.contains("length") && err.contains("negative"), "{err}");
171    }
172
173    #[test]
174    fn primary_key_where_is_rejected() {
175        let err = parse_err(
176            r#"<table name="T"><columns><column name="ID" type="int"/></columns><keys><primary where="ID &gt; 0"><column name="ID"/></primary></keys></table>"#,
177        );
178        assert!(err.contains("<primary>") && err.contains("where"), "{err}");
179    }
180
181    #[test]
182    fn case_sensitive_text_applies_to_every_schema_and_is_rejected_on_schema() {
183        let xml = r#"<database xmlns="http://stano.com/database" caseSensitiveText="false">
184            <schema name="s"><table name="T"><columns><column name="A" type="int"/></columns></table></schema>
185        </database>"#;
186        let database = parse_database_xml(xml).expect("parse ok");
187        assert!(!database.schemas().iter().any(|s| s.case_sensitive_text()));
188
189        let err = parse_err(r#"<schema name="s" caseSensitiveText="false"/>"#);
190        assert!(err.contains("caseSensitiveText"), "{err}");
191    }
192
193    #[test]
194    fn empty_key_is_rejected() {
195        let err = parse_err(
196            r#"<table name="T"><columns><column name="ID" type="int"/></columns><keys><primary/></keys></table>"#,
197        );
198        assert!(err.contains("at least one <column>"), "{err}");
199    }
200
201    #[test]
202    fn duplicate_column_checks_are_rejected() {
203        let err = parse_err(
204            r#"<table name="T"><columns><column name="ID" type="int"><check databaseType="h2">ID &gt; 0</check><check databaseType="h2">ID &gt; 1</check></column></columns></table>"#,
205        );
206        assert!(
207            err.contains("more than one check") && err.contains("h2"),
208            "{err}"
209        );
210        let err = parse_err(
211            r#"<table name="T"><columns><column name="ID" type="int"><check>ID &gt; 0</check><check>ID &gt; 1</check></column></columns></table>"#,
212        );
213        assert!(err.contains("more than one check"), "{err}");
214    }
215
216    #[test]
217    fn unknown_elements_are_rejected() {
218        let err = parse_err("<bogus/>");
219        assert!(
220            err.contains("<bogus>") && err.contains("<database>"),
221            "{err}"
222        );
223        let err = parse_err(
224            r#"<table name="T"><columns><column name="ID" type="int"/></columns><bogus/></table>"#,
225        );
226        assert!(err.contains("<bogus>") && err.contains("<table>"), "{err}");
227        let err = parse_err(
228            r#"<table name="T"><columns><column name="ID" type="int"><bogus/></column></columns></table>"#,
229        );
230        assert!(err.contains("<bogus>") && err.contains("<column>"), "{err}");
231    }
232
233    #[test]
234    fn dangling_relation_target_returns_error_instead_of_panicking() {
235        let xml = wrap(
236            r#"
237            <table name="Child">
238                <columns>
239                    <column name="ParentId" type="int" required="true"/>
240                </columns>
241                <relations>
242                    <relation src="ParentId" table="Regoin" column="Id" type="cascade"/>
243                </relations>
244            </table>
245            "#,
246        );
247
248        let result = parse_database_xml(&xml);
249
250        assert!(result.is_err());
251        assert!(result.unwrap_err().contains("Regoin"));
252    }
253
254    #[test]
255    fn reverse_relation_resolves_child_in_a_different_named_schema() {
256        // The child ("sales.order_item") lives in a non-default schema and references a
257        // parent ("product") in the default schema. The reverse relation attached to
258        // "product" must be able to resolve "sales.order_item" back - not just "order_item"
259        // unqualified, which would incorrectly look for it in the default schema.
260        let xml = wrap(
261            r#"
262            <table name="Product">
263                <columns>
264                    <column name="Id" type="sequence" required="true"/>
265                </columns>
266                <keys>
267                    <primary>
268                        <column name="Id"/>
269                    </primary>
270                </keys>
271            </table>
272            <schema name="sales">
273                <table name="OrderItem">
274                    <columns>
275                        <column name="ProductId" type="int" required="true"/>
276                    </columns>
277                    <relations>
278                        <relation src="ProductId" table="Product" column="Id" type="cascade"/>
279                    </relations>
280                </table>
281            </schema>
282            "#,
283        );
284
285        let database = parse_database_xml(&xml).expect("parse ok");
286
287        let default_schema = database
288            .schemas()
289            .iter()
290            .find(|s| s.schema_name().is_none())
291            .unwrap();
292        let product = default_schema.get_table("Product");
293        let reverse_relations = product.reverse_relations();
294        assert_eq!(reverse_relations.len(), 1);
295        assert_eq!(reverse_relations[0].from_table_name(), "sales.OrderItem");
296    }
297
298    #[test]
299    fn function_with_unrecognized_database_type_returns_error_instead_of_vanishing() {
300        let xml = wrap(
301            r#"
302            <function name="my_func">
303                <sql databaseType="postgres">select 1</sql>
304            </function>
305            "#,
306        );
307
308        let result = parse_database_xml(&xml);
309
310        assert!(result.is_err());
311        let err = result.unwrap_err();
312        assert!(err.contains("my_func"));
313        assert!(err.contains("postgres"));
314    }
315
316    #[test]
317    fn view_with_unrecognized_database_type_returns_error_instead_of_silently_applying_to_all() {
318        let xml = wrap(
319            r#"
320            <view name="my_view" databaseType="postgres">select 1</view>
321            "#,
322        );
323
324        let result = parse_database_xml(&xml);
325
326        assert!(result.is_err());
327        let err = result.unwrap_err();
328        assert!(err.contains("my_view"));
329        assert!(err.contains("postgres"));
330    }
331
332    #[test]
333    fn view_with_no_database_type_still_parses_and_applies_to_every_database() {
334        let xml = wrap(
335            r#"
336            <view name="my_view">select 1</view>
337            "#,
338        );
339
340        let database = parse_database_xml(&xml).expect("parse ok");
341        let view = &database.default_schema().all_views()[0];
342        assert_eq!(view.database_type(), None);
343    }
344
345    #[test]
346    fn missing_required_table_name_returns_error_instead_of_defaulting_to_empty_string() {
347        let xml = wrap(
348            r#"
349            <table>
350                <columns>
351                    <column name="Id" type="int"/>
352                </columns>
353            </table>
354            "#,
355        );
356
357        let result = parse_database_xml(&xml);
358
359        assert!(result.is_err());
360        let err = result.unwrap_err();
361        assert!(err.contains("table"));
362        assert!(err.contains("name"));
363    }
364
365    #[test]
366    fn unrecognized_relation_type_returns_error_instead_of_defaulting_to_enforce() {
367        let xml = wrap(
368            r#"
369            <table name="Child">
370                <columns>
371                    <column name="ParentId" type="int" required="true"/>
372                </columns>
373                <relations>
374                    <relation src="ParentId" table="Parent" column="Id" type="cascde"/>
375                </relations>
376            </table>
377            <table name="Parent">
378                <columns>
379                    <column name="Id" type="int" required="true"/>
380                </columns>
381            </table>
382            "#,
383        );
384
385        let result = parse_database_xml(&xml);
386
387        assert!(result.is_err());
388        let err = result.unwrap_err();
389        assert!(err.contains("cascde"));
390    }
391
392    #[test]
393    fn unrecognized_lock_escalation_returns_error_instead_of_defaulting_to_auto() {
394        let xml = wrap(
395            r#"
396            <table name="Widget" lockEscalation="sometimes">
397                <columns>
398                    <column name="Id" type="int"/>
399                </columns>
400            </table>
401            "#,
402        );
403
404        let result = parse_database_xml(&xml);
405
406        assert!(result.is_err());
407        assert!(result.unwrap_err().contains("sometimes"));
408    }
409
410    #[test]
411    fn unrecognized_other_sql_order_returns_error_instead_of_defaulting_to_top() {
412        let xml = wrap(
413            r#"
414            <otherSql databaseType="postgresql" order="middle">select 1</otherSql>
415            "#,
416        );
417
418        let result = parse_database_xml(&xml);
419
420        assert!(result.is_err());
421        assert!(result.unwrap_err().contains("middle"));
422    }
423
424    #[test]
425    fn unrecognized_aggregation_frequency_returns_error_instead_of_defaulting_to_monthly() {
426        let xml = wrap(
427            r#"
428            <table name="Widget">
429                <columns>
430                    <column name="Id" type="int"/>
431                    <column name="Amount" type="int"/>
432                </columns>
433                <aggregations>
434                    <aggregate destinationTable="WidgetAgg" dateColumn="Id" timestampColumn="Id" frequency="fortnightly">
435                        <sum sourceColumn="Amount" destinationColumn="TotalAmount"/>
436                        <group>
437                            <column source="Id" destination="Id"/>
438                        </group>
439                    </aggregate>
440                </aggregations>
441            </table>
442            "#,
443        );
444
445        let result = parse_database_xml(&xml);
446
447        assert!(result.is_err());
448        assert!(result.unwrap_err().contains("fortnightly"));
449    }
450
451    #[test]
452    fn invalid_column_type_returns_error_instead_of_panicking() {
453        let xml = wrap(
454            r#"
455            <table name="Widget">
456                <columns>
457                    <column name="Name" type="varchr"/>
458                </columns>
459            </table>
460            "#,
461        );
462
463        let result = parse_database_xml(&xml);
464
465        assert!(result.is_err());
466        let err = result.unwrap_err();
467        assert!(err.contains("Widget"));
468        assert!(err.contains("Name"));
469    }
470
471    #[test]
472    fn primary_key_with_where_predicate_returns_error() {
473        let xml = wrap(
474            r#"
475            <table name="Widget">
476                <columns>
477                    <column name="Id" type="int" required="true"/>
478                </columns>
479                <keys>
480                    <primary where="1=1">
481                        <column name="Id"/>
482                    </primary>
483                </keys>
484            </table>
485            "#,
486        );
487
488        let result = parse_database_xml(&xml);
489
490        assert!(result.is_err());
491        assert!(result.unwrap_err().contains("primary"));
492    }
493
494    #[test]
495    fn clustered_unique_key_with_where_predicate_returns_error() {
496        let xml = wrap(
497            r#"
498            <table name="Widget">
499                <columns>
500                    <column name="ParentId" type="int"/>
501                </columns>
502                <keys>
503                    <unique cluster="true" where="ParentId is not null">
504                        <column name="ParentId"/>
505                    </unique>
506                </keys>
507            </table>
508            "#,
509        );
510
511        let result = parse_database_xml(&xml);
512
513        assert!(result.is_err());
514        assert!(result.unwrap_err().contains("clustered"));
515    }
516
517    #[test]
518    fn unique_key_with_where_predicate_is_promoted_to_a_filtered_unique_index() {
519        let xml = wrap(
520            r#"
521            <table name="Widget">
522                <columns>
523                    <column name="ParentId" type="int"/>
524                </columns>
525                <keys>
526                    <unique where="ParentId is not null">
527                        <column name="ParentId"/>
528                    </unique>
529                </keys>
530            </table>
531            "#,
532        );
533
534        let database = parse_database_xml(&xml).expect("parse ok");
535        let schema = &database.schemas()[0];
536        let table = schema.get_table("Widget");
537
538        assert!(table.keys().is_empty());
539        assert_eq!(table.indexes().len(), 1);
540        let index = &table.indexes()[0];
541        assert!(index.is_unique());
542        assert_eq!(index.filter(), Some("ParentId is not null"));
543    }
544
545    #[test]
546    fn index_where_predicate_is_parsed() {
547        let xml = wrap(
548            r#"
549            <table name="Widget">
550                <columns>
551                    <column name="ParentId" type="int"/>
552                </columns>
553                <keys>
554                    <index unique="true" where="ParentId is not null">
555                        <column name="ParentId"/>
556                    </index>
557                </keys>
558            </table>
559            "#,
560        );
561
562        let database = parse_database_xml(&xml).expect("parse ok");
563        let schema = &database.schemas()[0];
564        let table = schema.get_table("Widget");
565
566        assert_eq!(table.indexes().len(), 1);
567        let index = &table.indexes()[0];
568        assert!(index.is_unique());
569        assert_eq!(index.filter(), Some("ParentId is not null"));
570    }
571
572    #[test]
573    fn aggregate_columns_keep_document_order() {
574        let xml = wrap(
575            r#"
576            <table name="T">
577                <columns><column name="ID" type="int"/></columns>
578                <aggregations>
579                    <aggregate destinationTable="D" dateColumn="Day" timestampColumn="Stamp" frequency="daily">
580                        <sum sourceColumn="ID" destinationColumn="S1"/>
581                        <count destinationColumn="C1"/>
582                        <sum sourceColumn="ID" destinationColumn="S2"/>
583                        <group><column source="ID" destination="ID"/></group>
584                    </aggregate>
585                </aggregations>
586            </table>
587            "#,
588        );
589
590        let database = parse_database_xml(&xml).expect("parse ok");
591        let table = database.schemas()[0].get_table("T");
592        let columns = table.aggregations()[0].aggregation_columns();
593
594        let kinds: Vec<_> = columns
595            .iter()
596            .map(|c| (c.aggregation_type(), c.destination_column()))
597            .collect();
598        assert_eq!(
599            kinds,
600            vec![
601                (AggregationType::Sum, "S1"),
602                (AggregationType::Count, "C1"),
603                (AggregationType::Sum, "S2"),
604            ]
605        );
606    }
607
608    #[test]
609    fn aggregate_with_multiple_groups_returns_error() {
610        let xml = wrap(
611            r#"
612            <table name="T">
613                <columns><column name="ID" type="int"/></columns>
614                <aggregations>
615                    <aggregate destinationTable="D" dateColumn="Day" timestampColumn="Stamp" frequency="daily">
616                        <count destinationColumn="C1"/>
617                        <group><column source="ID" destination="ID"/></group>
618                        <group><column source="ID" destination="ID"/></group>
619                    </aggregate>
620                </aggregations>
621            </table>
622            "#,
623        );
624
625        let result = parse_database_xml(&xml);
626
627        assert!(result.unwrap_err().contains("more than one <group>"));
628    }
629
630    #[test]
631    fn aggregate_without_group_returns_error() {
632        let xml = wrap(
633            r#"
634            <table name="T">
635                <columns><column name="ID" type="int"/></columns>
636                <aggregations>
637                    <aggregate destinationTable="D" dateColumn="Day" timestampColumn="Stamp" frequency="daily">
638                        <count destinationColumn="C1"/>
639                    </aggregate>
640                </aggregations>
641            </table>
642            "#,
643        );
644
645        let result = parse_database_xml(&xml);
646
647        assert!(result.unwrap_err().contains("missing <group>"));
648    }
649}