schema_parser/parser/
xml_parser.rs1use crate::parse_database_roxml;
2use crate::parser::convert::convert_database;
3use crate::parser::nodes::DatabaseXml;
4use schema_model::model::database_model::DatabaseModel;
5
6pub 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 }
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 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 > 0</check>
62 <check databaseType="postgresql">Qty > 100</check>
63 <check databaseType="h2">Qty > 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 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 > 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 < 9</constraint>
108 <constraint name="CK_PG" databaseType="postgresql">A < 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 > 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 > 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 > 0</check><check databaseType="h2">ID > 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 > 0</check><check>ID > 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 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}