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 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 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 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}