1use crate::parser::nodes::*;
2use roxmltree::{Document, Node};
3
4const NS: &str = "http://stano.com/database";
5
6pub fn parse_database_roxml(xml: &str) -> Result<DatabaseXml, String> {
7 let doc = Document::parse(xml).map_err(|e| format!("XML parse error: {e}"))?;
8 let root = doc
9 .descendants()
10 .find(|n| n.has_tag_name((NS, "database")))
11 .ok_or_else(|| "No <database> root element found".to_string())?;
12
13 Ok(parse_database_node(root))
14}
15
16fn parse_database_node(node: Node) -> DatabaseXml {
17 let version = attr_string(node, "version");
18 let foreign_key_mode = attr_string(node, "foreignKeyMode");
19 let boolean_mode = attr_string(node, "booleanMode");
20 let case_sensitive_text = attr_bool(node, "caseSensitiveText");
21
22 let mut tables = Vec::new();
23 let mut enums = Vec::new();
24 let mut views = Vec::new();
25 let mut functions = Vec::new();
26 let mut procedures = Vec::new();
27 let mut other_sql = Vec::new();
28 let mut schemas = Vec::new();
29
30 for child in node.children().filter(|n| n.is_element()) {
31 match child.tag_name().name() {
32 "table" if child.has_tag_name((NS, "table")) => tables.push(parse_table_node(child)),
33 "enum" if child.has_tag_name((NS, "enum")) => enums.push(parse_enum_node(child)),
34 "view" if child.has_tag_name((NS, "view")) => views.push(parse_view_node(child)),
35 "function" if child.has_tag_name((NS, "function")) => functions.push(parse_function_node(child)),
36 "procedure" if child.has_tag_name((NS, "procedure")) => procedures.push(parse_procedure_node(child)),
37 "otherSql" if child.has_tag_name((NS, "otherSql")) => other_sql.push(parse_other_sql_node(child)),
38 "schema" if child.has_tag_name((NS, "schema")) => schemas.push(parse_schema_node(child)),
39 _ => {}
40 }
41 }
42
43 DatabaseXml {
44 version,
45 foreign_key_mode,
46 boolean_mode,
47 case_sensitive_text,
48 tables,
49 enums,
50 views,
51 functions,
52 procedures,
53 other_sql,
54 schemas,
55 }
56}
57
58fn parse_schema_node(node: Node) -> SchemaXml {
59 let name = attr_string_required(node, "name");
60 let case_sensitive_text = attr_bool(node, "caseSensitiveText");
61
62 let mut tables = Vec::new();
63 let mut enums = Vec::new();
64 let mut views = Vec::new();
65 let mut functions = Vec::new();
66 let mut procedures = Vec::new();
67 let mut other_sql = Vec::new();
68
69 for child in node.children().filter(|n| n.is_element()) {
70 match child.tag_name().name() {
71 "table" if child.has_tag_name((NS, "table")) => tables.push(parse_table_node(child)),
72 "enum" if child.has_tag_name((NS, "enum")) => enums.push(parse_enum_node(child)),
73 "view" if child.has_tag_name((NS, "view")) => views.push(parse_view_node(child)),
74 "function" if child.has_tag_name((NS, "function")) => functions.push(parse_function_node(child)),
75 "procedure" if child.has_tag_name((NS, "procedure")) => procedures.push(parse_procedure_node(child)),
76 "otherSql" if child.has_tag_name((NS, "otherSql")) => other_sql.push(parse_other_sql_node(child)),
77 _ => {}
78 }
79 }
80
81 SchemaXml { name, case_sensitive_text, tables, enums, views, functions, procedures, other_sql }
82}
83
84fn parse_table_node(node: Node) -> TableXml {
85 let name = attr_string_required(node, "name");
86 let data_opt = attr_bool(node, "data");
87 let no_export = attr_bool(node, "noExport");
88 let export_data_column = attr_string(node, "exportDataColumn");
89 let compress = attr_bool(node, "compress");
90 let lock_escalation = attr_string(node, "lockEscalation");
91
92 let mut columns: Option<ColumnsXml> = None;
93 let mut keys: Option<KeysXml> = None;
94 let mut relations: Option<RelationsXml> = None;
95 let mut triggers: Option<TriggersXml> = None;
96 let mut constraints: Option<ConstraintsXml> = None;
97 let mut aggregations: Option<AggregationsXml> = None;
98 let mut initial_data: Option<InitialDataXml> = None;
99
100 for child in node.children().filter(|n| n.is_element()) {
101 if child.has_tag_name((NS, "columns")) {
102 columns = Some(parse_columns_node(child));
103 } else if child.has_tag_name((NS, "keys")) {
104 keys = Some(parse_keys_node(child));
105 } else if child.has_tag_name((NS, "relations")) {
106 relations = Some(parse_relations_node(child));
107 } else if child.has_tag_name((NS, "triggers")) {
108 triggers = Some(parse_triggers_node(child));
109 } else if child.has_tag_name((NS, "constraints")) {
110 constraints = Some(parse_constraints_node(child));
111 } else if child.has_tag_name((NS, "aggregations")) {
112 aggregations = Some(parse_aggregations_node(child));
113 } else if child.has_tag_name((NS, "initialData")) {
114 initial_data = Some(parse_initial_data_node(child));
115 }
116 }
117
118 TableXml {
119 name,
120 data_opt,
121 no_export,
122 export_data_column,
123 compress,
124 lock_escalation,
125 columns,
126 keys,
127 relations,
128 triggers,
129 constraints,
130 aggregations,
131 initial_data,
132 }
133}
134
135fn parse_columns_node(node: Node) -> ColumnsXml {
136 let mut cols = Vec::new();
137 for c in node.children().filter(|n| n.has_tag_name((NS, "column"))) {
138 cols.push(parse_column_node(c));
139 }
140 ColumnsXml { column: cols }
141}
142
143fn parse_column_node(node: Node) -> ColumnXml {
144 ColumnXml {
145 name: attr_string_required(node, "name"),
146 r#type: attr_string_required(node, "type"),
147 length: attr_i32(node, "length"),
148 scale: attr_i32(node, "scale"),
149 required: attr_bool(node, "required"),
150 default_value: attr_string(node, "default"),
151 generated: attr_string(node, "generated"),
152 enum_type: attr_string(node, "enumType"),
153 element_type: attr_string(node, "elementType"),
154 min_value: attr_f64(node, "minValue"),
155 max_value: attr_f64(node, "maxValue"),
156 check: node
157 .children()
158 .find(|n| n.has_tag_name((NS, "check")))
159 .map(parse_check_node),
160 }
161}
162
163fn parse_check_node(node: Node) -> CheckXml {
164 let text = node.text().map(|s| s.trim()).filter(|s| !s.is_empty());
165 CheckXml { value: text.map(|s| s.to_string()) }
166}
167
168fn parse_keys_node(node: Node) -> KeysXml {
169 let mut primary: Option<KeyColumnsXml> = None;
170 let mut uniques: Vec<KeyColumnsXml> = Vec::new();
171 let mut indexes: Vec<IndexXml> = Vec::new();
172
173 for c in node.children().filter(|n| n.is_element()) {
174 if c.has_tag_name((NS, "primary")) {
175 primary = Some(parse_key_columns_node(c));
176 } else if c.has_tag_name((NS, "unique")) {
177 uniques.push(parse_key_columns_node(c));
178 } else if c.has_tag_name((NS, "index")) {
179 indexes.push(parse_index_node(c));
180 }
181 }
182
183 KeysXml { primary, uniques, indexes }
184}
185
186fn parse_key_columns_node(node: Node) -> KeyColumnsXml {
187 let mut columns = Vec::new();
188 for c in node.children().filter(|n| n.has_tag_name((NS, "column"))) {
189 columns.push(KeyColumnXml {
190 name: attr_string_required(c, "name"),
191 });
192 }
193 let cluster = attr_bool(node, "cluster");
194 KeyColumnsXml { columns, cluster }
195}
196
197fn parse_index_node(node: Node) -> IndexXml {
198 let mut columns = Vec::new();
199 for c in node.children().filter(|n| n.has_tag_name((NS, "column"))) {
200 columns.push(KeyColumnXml { name: attr_string_required(c, "name") });
201 }
202 IndexXml {
203 columns,
204 include: attr_string(node, "include"),
205 compress: attr_bool(node, "compress"),
206 unique: attr_bool(node, "unique"),
207 }
208}
209
210fn parse_relations_node(node: Node) -> RelationsXml {
211 let mut rels = Vec::new();
212 for r in node.children().filter(|n| n.has_tag_name((NS, "relation"))) {
213 rels.push(RelationXml {
214 src: attr_string_required(r, "src"),
215 table: attr_string_required(r, "table"),
216 column: attr_string_required(r, "column"),
217 r#type: attr_string_required(r, "type"),
218 disable_usage_checking: attr_bool(r, "disableUsageChecking"),
219 });
220 }
221 RelationsXml { relation: rels }
222}
223
224fn parse_view_node(node: Node) -> ViewXml {
225 ViewXml {
226 name: attr_string_required(node, "name"),
227 database_type: attr_string(node, "databaseType"),
228 sql: collect_text(node),
229 }
230}
231
232fn parse_function_node(node: Node) -> FunctionXml {
233 let name = attr_string_required(node, "name");
234 let mut sql = Vec::new();
235 for s in node.children().filter(|n| n.has_tag_name((NS, "sql"))) {
236 sql.push(VendorSqlXml {
237 database_type: attr_string_required(s, "databaseType"),
238 sql: collect_text(s),
239 });
240 }
241 FunctionXml { name, sql }
242}
243
244fn parse_procedure_node(node: Node) -> ProcedureXml {
245 let name = attr_string_required(node, "name");
246 let mut sql = Vec::new();
247 for s in node.children().filter(|n| n.has_tag_name((NS, "sql"))) {
248 sql.push(VendorSqlXml {
249 database_type: attr_string_required(s, "databaseType"),
250 sql: collect_text(s),
251 });
252 }
253 ProcedureXml { name, sql }
254}
255
256fn parse_other_sql_node(node: Node) -> OtherSqlXml {
257 let database_type = attr_string_required(node, "databaseType");
258 let order_text = attr_string_required(node, "order");
259 let order = match order_text.as_str() {
260 "top" | "Top" => OtherSqlOrderXml::Top,
261 "bottom" | "Bottom" => OtherSqlOrderXml::Bottom,
262 _ => OtherSqlOrderXml::Top,
263 };
264 OtherSqlXml { database_type, order, sql: collect_text(node) }
265}
266
267fn parse_enum_node(node: Node) -> EnumXml {
268 let name = attr_string_required(node, "name");
269 let mut value = Vec::new();
270 for v in node.children().filter(|n| n.has_tag_name((NS, "value"))) {
271 value.push(EnumValueXml { name: attr_string_required(v, "name"), code: attr_string(v, "code") });
272 }
273 EnumXml { name, value }
274}
275
276fn parse_triggers_node(node: Node) -> TriggersXml {
277 let mut update = Vec::new();
278 let mut delete = Vec::new();
279 for c in node.children().filter(|n| n.is_element()) {
280 if c.has_tag_name((NS, "update")) {
281 update.push(TriggerXml { database_type: attr_string_required(c, "databaseType"), sql: collect_text(c) });
282 } else if c.has_tag_name((NS, "delete")) {
283 delete.push(TriggerXml { database_type: attr_string_required(c, "databaseType"), sql: collect_text(c) });
284 }
285 }
286 TriggersXml { update, delete }
287}
288
289fn parse_constraints_node(node: Node) -> ConstraintsXml {
290 let mut constraint = Vec::new();
291 for c in node.children().filter(|n| n.has_tag_name((NS, "constraint"))) {
292 constraint.push(ConstraintXml {
293 name: attr_string_required(c, "name"),
294 database_type: attr_string(c, "databaseType"),
295 sql: collect_text(c),
296 });
297 }
298 ConstraintsXml { constraint }
299}
300
301fn parse_aggregations_node(node: Node) -> AggregationsXml {
302 let mut aggregate = Vec::new();
303 for a in node.children().filter(|n| n.has_tag_name((NS, "aggregate"))) {
304 aggregate.push(parse_aggregate_node(a));
305 }
306 AggregationsXml { aggregate }
307}
308
309fn parse_aggregate_node(node: Node) -> AggregateXml {
310 let mut sum = Vec::new();
311 let mut count = Vec::new();
312 let mut group: Option<GroupXml> = None;
313
314 for c in node.children().filter(|n| n.is_element()) {
315 if c.has_tag_name((NS, "sum")) {
316 sum.push(SumXml {
317 source_column: attr_string_required(c, "sourceColumn"),
318 destination_column: attr_string_required(c, "destinationColumn"),
319 });
320 } else if c.has_tag_name((NS, "count")) {
321 count.push(CountXml { destination_column: attr_string_required(c, "destinationColumn") });
322 } else if c.has_tag_name((NS, "group")) {
323 group = Some(parse_group_node(c));
324 }
325 }
326
327 AggregateXml {
328 sum,
329 count,
330 group: group.unwrap_or_else(|| GroupXml { column: Vec::new() }),
331 destination_table: attr_string_required(node, "destinationTable"),
332 date_column: attr_string_required(node, "dateColumn"),
333 timestamp_column: attr_string_required(node, "timestampColumn"),
334 frequency: attr_string_required(node, "frequency"),
335 criteria: attr_string(node, "criteria"),
336 }
337}
338
339fn parse_group_node(node: Node) -> GroupXml {
340 let mut column = Vec::new();
341 for c in node.children().filter(|n| n.has_tag_name((NS, "column"))) {
342 column.push(GroupColumnXml {
343 source: attr_string_required(c, "source"),
344 destination: attr_string_required(c, "destination"),
345 source_derived_from: attr_string(c, "sourceDerivedFrom"),
346 });
347 }
348 GroupXml { column }
349}
350
351fn parse_initial_data_node(node: Node) -> InitialDataXml {
352 let mut sql = Vec::new();
353 for s in node.children().filter(|n| n.has_tag_name((NS, "sql"))) {
354 sql.push(InitialSqlXml {
355 database_type: attr_string(s, "databaseType"),
356 sql: collect_text(s),
357 });
358 }
359 InitialDataXml { sql }
360}
361
362fn attr_string(node: Node, name: &str) -> Option<String> {
364 node.attribute(name).map(|s| s.to_string())
365}
366
367fn attr_string_required(node: Node, name: &str) -> String {
368 node.attribute(name)
369 .unwrap_or("")
370 .to_string()
371}
372
373fn attr_bool(node: Node, name: &str) -> Option<bool> {
374 node.attribute(name).and_then(|v| match v {
375 "true" | "1" | "yes" | "on" => Some(true),
376 "false" | "0" | "no" | "off" => Some(false),
377 _ => None,
378 })
379}
380
381fn attr_i32(node: Node, name: &str) -> Option<i32> {
382 node.attribute(name).and_then(|v| v.parse::<i32>().ok())
383}
384
385fn attr_f64(node: Node, name: &str) -> Option<f64> {
386 node.attribute(name).and_then(|v| v.parse::<f64>().ok())
387}
388
389fn collect_text(node: Node) -> String {
390 let mut out = String::new();
391 for n in node.children() {
392 if n.is_text() {
393 out.push_str(n.text().unwrap_or(""));
394 }
395 }
396 out.trim().to_string()
397}
398
399#[cfg(test)]
400mod tests {
401 use super::*;
402 use std::fs;
403
404 #[test]
405 fn parse_with_roxmltree_sample() {
406 let xml = fs::read_to_string("tests/resources/schema-parser-test-schema.xml").expect("resource present");
407 let db = parse_database_roxml(&xml).expect("parsed");
408 assert!(db.version.is_some());
409 assert!(!db.tables.is_empty());
410 assert!(db.schemas.is_empty() || !db.schemas[0].tables.is_empty());
411 }
412}