Skip to main content

schema_parser/parser/
roxml_parser.rs

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
362// -------- Utils --------
363fn 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}