schema_parser/parser/
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 = parse_database_roxml(xml).map_err(|e| format!("XML parse error: {e}"))?;
9 convert_database(database_xml)
10
11 }
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 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 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}