Skip to main content

schema_reverse_engineer/
xml_writer.rs

1use crate::error::SchemaReverseEngineerError;
2use schema_model::model::column::Column;
3use schema_model::model::constraint::Constraint;
4use schema_model::model::database_model::DatabaseModel;
5use schema_model::model::enum_type::EnumType;
6use schema_model::model::key::Key;
7use schema_model::model::relation::Relation;
8use schema_model::model::schema::Schema;
9use schema_model::model::table::Table;
10use schema_model::model::types::{BooleanMode, ForeignKeyMode, KeyType};
11use schema_model::model::view::View;
12use std::fmt::Write as _;
13
14const NAMESPACE: &str = "http://stano.com/database";
15
16/// Serializes a `DatabaseModel` to the schema-rs XML schema definition format (see
17/// `schema-xsd/schema.xsd`), the inverse of `schema_parser::parse_database_xml`.
18pub fn write_database_xml(model: &DatabaseModel) -> Result<String, SchemaReverseEngineerError> {
19    let mut out = String::new();
20    out.push_str("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
21    let _ = writeln!(
22        out,
23        "<database xmlns=\"{}\" foreignKeyMode=\"{}\" booleanMode=\"{}\">",
24        NAMESPACE,
25        foreign_key_mode_str(model.foreign_key_mode()),
26        boolean_mode_str(model.boolean_mode())
27    );
28
29    for schema in model.schemas() {
30        match schema.schema_name() {
31            Some(name) => {
32                push_indent(&mut out, 1);
33                let _ = writeln!(out, "<schema name=\"{}\">", xml_escape_attr(name));
34                write_schema_body(&mut out, schema, 2)?;
35                push_indent(&mut out, 1);
36                out.push_str("</schema>\n");
37            }
38            None => write_schema_body(&mut out, schema, 1)?,
39        }
40    }
41
42    out.push_str("</database>\n");
43    Ok(out)
44}
45
46fn write_schema_body(
47    out: &mut String,
48    schema: &Schema,
49    indent: usize,
50) -> Result<(), SchemaReverseEngineerError> {
51    for enum_type in schema.enum_types() {
52        write_enum(out, enum_type, indent);
53    }
54    for table in schema.tables() {
55        write_table(out, table, indent)?;
56    }
57    for view in schema.all_views() {
58        write_view(out, view, indent);
59    }
60    Ok(())
61}
62
63fn write_enum(out: &mut String, enum_type: &EnumType, indent: usize) {
64    push_indent(out, indent);
65    let _ = writeln!(out, "<enum name=\"{}\">", xml_escape_attr(enum_type.name()));
66    for value in enum_type.values() {
67        push_indent(out, indent + 1);
68        let _ = write!(out, "<value name=\"{}\"", xml_escape_attr(value.name()));
69        if value.code() != value.name() {
70            let _ = write!(out, " code=\"{}\"", xml_escape_attr(value.code()));
71        }
72        out.push_str("/>\n");
73    }
74    push_indent(out, indent);
75    out.push_str("</enum>\n\n");
76}
77
78fn write_view(out: &mut String, view: &View, indent: usize) {
79    push_indent(out, indent);
80    let _ = writeln!(out, "<view name=\"{}\">", xml_escape_attr(view.name()));
81    push_indent(out, indent + 1);
82    write_cdata(out, view.sql());
83    out.push('\n');
84    push_indent(out, indent);
85    out.push_str("</view>\n\n");
86}
87
88fn write_table(
89    out: &mut String,
90    table: &Table,
91    indent: usize,
92) -> Result<(), SchemaReverseEngineerError> {
93    push_indent(out, indent);
94    let _ = writeln!(out, "<table name=\"{}\">", xml_escape_attr(table.name()));
95
96    write_columns(out, table.columns(), indent + 1);
97    write_keys(out, table, indent + 1)?;
98    write_relations(out, table.relations(), indent + 1);
99    write_constraints(out, table.constraints(), indent + 1);
100
101    push_indent(out, indent);
102    out.push_str("</table>\n\n");
103    Ok(())
104}
105
106fn write_columns(out: &mut String, columns: &[Column], indent: usize) {
107    push_indent(out, indent);
108    out.push_str("<columns>\n");
109    for column in columns {
110        write_column(out, column, indent + 1);
111    }
112    push_indent(out, indent);
113    out.push_str("</columns>\n");
114}
115
116fn write_column(out: &mut String, column: &Column, indent: usize) {
117    push_indent(out, indent);
118    let _ = write!(
119        out,
120        "<column name=\"{}\" type=\"{}\"",
121        xml_escape_attr(column.name()),
122        column.column_type().name().to_lowercase()
123    );
124    if column.length() > 0 {
125        let _ = write!(out, " length=\"{}\"", column.length());
126    }
127    if column.scale() > 0 {
128        let _ = write!(out, " scale=\"{}\"", column.scale());
129    }
130    if column.required() {
131        out.push_str(" required=\"true\"");
132    }
133    if let Some(default) = column.default_constraint() {
134        let _ = write!(out, " default=\"{}\"", xml_escape_attr(default));
135    }
136    if let Some(generated) = column.generated() {
137        let _ = write!(out, " generated=\"{}\"", xml_escape_attr(generated));
138    }
139    if let Some(enum_type) = column.enum_type() {
140        let _ = write!(out, " enumType=\"{}\"", xml_escape_attr(enum_type));
141    }
142    if let Some(element_type) = column.element_type() {
143        let _ = write!(out, " elementType=\"{}\"", xml_escape_attr(element_type));
144    }
145    if let Some(min_value) = column.min_value() {
146        let _ = write!(out, " minValue=\"{}\"", min_value);
147    }
148    if let Some(max_value) = column.max_value() {
149        let _ = write!(out, " maxValue=\"{}\"", max_value);
150    }
151
152    if let Some(check) = column.check_constraint() {
153        out.push_str(">\n");
154        push_indent(out, indent + 1);
155        let _ = writeln!(out, "<check>{}</check>", xml_escape(check));
156        push_indent(out, indent);
157        out.push_str("</column>\n");
158    } else {
159        out.push_str("/>\n");
160    }
161}
162
163fn write_keys(
164    out: &mut String,
165    table: &Table,
166    indent: usize,
167) -> Result<(), SchemaReverseEngineerError> {
168    // The XSD requires a <primary> element whenever <keys> is present, so a table with no
169    // primary key can't emit unique/index keys either. Silently dropping them would lose data
170    // from the round trip, so a PK-less table with unique keys or indexes is a hard error
171    // instead (per the project's prefer-error-over-silent-coercion direction).
172    let Some(primary) = table.primary_key() else {
173        if table.keys().iter().any(|k| k.key_type() == KeyType::Unique)
174            || !table.indexes().is_empty()
175        {
176            return Err(SchemaReverseEngineerError::PkLessTableHasKeys(
177                table.name().to_string(),
178            ));
179        }
180        return Ok(());
181    };
182
183    push_indent(out, indent);
184    out.push_str("<keys>\n");
185    write_key_columns(out, "primary", primary, indent + 1);
186    for unique in table
187        .keys()
188        .iter()
189        .filter(|k| k.key_type() == KeyType::Unique)
190    {
191        write_key_columns(out, "unique", unique, indent + 1);
192    }
193    for index in table.indexes() {
194        write_index(out, index, indent + 1);
195    }
196    push_indent(out, indent);
197    out.push_str("</keys>\n");
198    Ok(())
199}
200
201fn write_key_columns(out: &mut String, tag: &str, key: &Key, indent: usize) {
202    push_indent(out, indent);
203    let _ = writeln!(out, "<{}>", tag);
204    for column in key.columns() {
205        push_indent(out, indent + 1);
206        let _ = writeln!(out, "<column name=\"{}\"/>", xml_escape_attr(column.name()));
207    }
208    push_indent(out, indent);
209    let _ = writeln!(out, "</{}>", tag);
210}
211
212fn write_index(out: &mut String, index: &Key, indent: usize) {
213    push_indent(out, indent);
214    let _ = write!(out, "<index");
215    if index.is_unique() {
216        out.push_str(" unique=\"true\"");
217    }
218    if let Some(include) = index.include() {
219        let _ = write!(out, " include=\"{}\"", xml_escape_attr(include));
220    }
221    if let Some(filter) = index.filter() {
222        let _ = write!(out, " where=\"{}\"", xml_escape_attr(filter));
223    }
224    out.push_str(">\n");
225    for column in index.columns() {
226        push_indent(out, indent + 1);
227        let _ = writeln!(out, "<column name=\"{}\"/>", xml_escape_attr(column.name()));
228    }
229    push_indent(out, indent);
230    out.push_str("</index>\n");
231}
232
233fn write_relations(out: &mut String, relations: &[Relation], indent: usize) {
234    if relations.is_empty() {
235        return;
236    }
237    push_indent(out, indent);
238    out.push_str("<relations>\n");
239    for relation in relations {
240        if relation.is_composite() {
241            push_indent(out, indent + 1);
242            let _ = writeln!(
243                out,
244                "<compositeRelation table=\"{}\" type=\"{}\">",
245                xml_escape_attr(relation.to_table_name()),
246                relation_type_str(relation.relation_type())
247            );
248            for (from_column, to_column) in relation.column_pairs() {
249                push_indent(out, indent + 2);
250                let _ = writeln!(
251                    out,
252                    "<column src=\"{}\" name=\"{}\"/>",
253                    xml_escape_attr(from_column),
254                    xml_escape_attr(to_column)
255                );
256            }
257            push_indent(out, indent + 1);
258            out.push_str("</compositeRelation>\n");
259        } else {
260            push_indent(out, indent + 1);
261            let _ = writeln!(
262                out,
263                "<relation src=\"{}\" table=\"{}\" column=\"{}\" type=\"{}\"/>",
264                xml_escape_attr(relation.from_column_name()),
265                xml_escape_attr(relation.to_table_name()),
266                xml_escape_attr(relation.to_column_name()),
267                relation_type_str(relation.relation_type())
268            );
269        }
270    }
271    push_indent(out, indent);
272    out.push_str("</relations>\n");
273}
274
275fn write_constraints(out: &mut String, constraints: &[Constraint], indent: usize) {
276    if constraints.is_empty() {
277        return;
278    }
279    push_indent(out, indent);
280    out.push_str("<constraints>\n");
281    for constraint in constraints {
282        push_indent(out, indent + 1);
283        let _ = writeln!(
284            out,
285            "<constraint name=\"{}\" databaseType=\"{}\">",
286            xml_escape_attr(constraint.name()),
287            database_type_str(constraint.database_type())
288        );
289        push_indent(out, indent + 2);
290        write_cdata(out, constraint.sql());
291        out.push('\n');
292        push_indent(out, indent + 1);
293        out.push_str("</constraint>\n");
294    }
295    push_indent(out, indent);
296    out.push_str("</constraints>\n");
297}
298
299fn relation_type_str(relation_type: schema_model::model::types::RelationType) -> &'static str {
300    use schema_model::model::types::RelationType;
301    match relation_type {
302        RelationType::Cascade => "cascade",
303        RelationType::Enforce => "enforce",
304        RelationType::SetNull => "setnull",
305        RelationType::DoNothing => "donothing",
306    }
307}
308
309fn boolean_mode_str(mode: BooleanMode) -> &'static str {
310    match mode {
311        BooleanMode::Native => "native",
312        BooleanMode::YesNo => "yesno",
313        BooleanMode::YN => "yn",
314    }
315}
316
317fn database_type_str(database_type: schema_model::model::types::DatabaseType) -> &'static str {
318    use schema_model::model::types::DatabaseType;
319    match database_type {
320        DatabaseType::Postgresql => "postgresql",
321        DatabaseType::Sqlite => "sqlite",
322        DatabaseType::SqlServer => "sqlserver",
323    }
324}
325
326fn foreign_key_mode_str(mode: ForeignKeyMode) -> &'static str {
327    match mode {
328        ForeignKeyMode::None => "none",
329        ForeignKeyMode::Relations => "relations",
330        ForeignKeyMode::Triggers => "triggers",
331    }
332}
333
334fn push_indent(out: &mut String, indent: usize) {
335    for _ in 0..indent {
336        out.push_str("  ");
337    }
338}
339
340/// Writes `content` as a `<![CDATA[...]]>` section, splitting any embedded `]]>` across
341/// adjacent CDATA sections first. The literal sequence `]]>` is illegal inside XML
342/// character data (not just "outside CDATA") - e.g. SQL text containing an array-slice
343/// like `arr[1:2]]>x` would otherwise close the CDATA section early and produce
344/// non-well-formed XML that fails to parse back.
345fn write_cdata(out: &mut String, content: &str) {
346    out.push_str("<![CDATA[");
347    out.push_str(&content.replace("]]>", "]]]]><![CDATA[>"));
348    out.push_str("]]>");
349}
350
351/// XML-escapes attribute and text content consistently (the Java writer inconsistently escaped
352/// index/unique key column names but not primary key column names -- here every column name and
353/// text value goes through the same escaping).
354fn xml_escape(value: &str) -> String {
355    let mut escaped = String::with_capacity(value.len());
356    for ch in value.chars() {
357        match ch {
358            '&' => escaped.push_str("&amp;"),
359            '<' => escaped.push_str("&lt;"),
360            '>' => escaped.push_str("&gt;"),
361            '"' => escaped.push_str("&quot;"),
362            '\'' => escaped.push_str("&apos;"),
363            _ => escaped.push(ch),
364        }
365    }
366    escaped
367}
368
369/// Escapes `value` for use inside a double-quoted attribute. On top of `xml_escape`, the
370/// whitespace characters that XML attribute-value normalization would otherwise collapse to
371/// a plain space on re-parse (newline, carriage return, tab) are written as character
372/// references, so a multi-line default expression round-trips unchanged.
373fn xml_escape_attr(value: &str) -> String {
374    let mut escaped = String::with_capacity(value.len());
375    for ch in xml_escape(value).chars() {
376        match ch {
377            '\n' => escaped.push_str("&#10;"),
378            '\r' => escaped.push_str("&#13;"),
379            '\t' => escaped.push_str("&#9;"),
380            _ => escaped.push(ch),
381        }
382    }
383    escaped
384}
385
386#[cfg(test)]
387mod tests {
388    use super::*;
389    use schema_model::builder::{ColumnBuilder, KeyBuilder, SchemaBuilder, TableBuilder};
390    use schema_model::model::column_type::ColumnType;
391    use schema_model::model::enum_type::EnumValue;
392    use schema_model::model::relation::Relation;
393    use schema_model::model::types::{DatabaseType, RelationType};
394
395    #[test]
396    fn writes_table_with_columns_pk_and_relation() {
397        let parent = TableBuilder::new(None::<&str>, "parent")
398            .add_column(
399                ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
400                    .required(true)
401                    .build(),
402            )
403            .add_key(KeyBuilder::new(KeyType::Primary).add_column("id").build())
404            .build();
405
406        let child = TableBuilder::new(None::<&str>, "child")
407            .add_column(
408                ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
409                    .required(true)
410                    .build(),
411            )
412            .add_column(
413                ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int)
414                    .required(true)
415                    .build(),
416            )
417            .add_key(KeyBuilder::new(KeyType::Primary).add_column("id").build())
418            .add_relation(Relation::new(
419                "parent",
420                "id",
421                "child",
422                "parent_id",
423                RelationType::Cascade,
424                false,
425            ))
426            .build();
427
428        let schema = SchemaBuilder::new(None::<&str>)
429            .add_table(parent)
430            .add_table(child)
431            .add_enum_type(EnumType::new(
432                "mood",
433                vec![EnumValue::new("HAPPY", None::<String>)],
434            ))
435            .add_view(View::new(
436                None::<&str>,
437                "v1",
438                "select 1",
439                Some(DatabaseType::Postgresql),
440            ))
441            .build();
442
443        let model =
444            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
445        let xml = write_database_xml(&model).unwrap();
446
447        assert!(xml.contains("<database xmlns=\"http://stano.com/database\""));
448        assert!(xml.contains("<table name=\"parent\">"));
449        assert!(xml.contains("<column name=\"id\" type=\"sequence\" required=\"true\"/>"));
450        assert!(xml.contains(
451            "<relation src=\"parent_id\" table=\"parent\" column=\"id\" type=\"cascade\"/>"
452        ));
453        assert!(xml.contains("<enum name=\"mood\">"));
454        assert!(xml.contains("<view name=\"v1\">"));
455    }
456
457    #[test]
458    fn write_cdata_splits_embedded_close_sequence() {
459        let mut out = String::new();
460        write_cdata(&mut out, "select arr[1:2]]>x from t");
461        assert!(
462            !out.contains("2]]>x"),
463            "the literal ]]> must not survive unescaped inside one CDATA block: {out}"
464        );
465        assert!(out.starts_with("<![CDATA["));
466        assert!(out.ends_with("]]>"));
467    }
468
469    #[test]
470    fn view_sql_containing_cdata_close_sequence_round_trips_through_the_real_parser() {
471        let view = View::new(
472            None::<&str>,
473            "v1",
474            "select * from t where arr[1:2]]>x",
475            None,
476        );
477        let schema = SchemaBuilder::new(None::<&str>).add_view(view).build();
478        let model =
479            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
480        let xml = write_database_xml(&model).unwrap();
481
482        let reparsed = schema_parser::parse_database_xml(&xml)
483            .expect("XML containing a ]]> sequence inside a view's SQL must still be well-formed");
484        let reparsed_view = &reparsed.default_schema().all_views()[0];
485        assert_eq!(reparsed_view.sql(), "select * from t where arr[1:2]]>x");
486    }
487
488    #[test]
489    fn constraint_sql_containing_cdata_close_sequence_round_trips_through_the_real_parser() {
490        let table = TableBuilder::new(None::<&str>, "t")
491            .add_column(ColumnBuilder::new(None::<&str>, "a", ColumnType::Int).build())
492            .add_constraint(schema_model::model::constraint::Constraint::new(
493                "ck_a",
494                "check (a[1:2]]>0)",
495                DatabaseType::Postgresql,
496            ))
497            .build();
498        let schema = SchemaBuilder::new(None::<&str>).add_table(table).build();
499        let model =
500            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
501        let xml = write_database_xml(&model).unwrap();
502
503        let reparsed = schema_parser::parse_database_xml(&xml).expect(
504            "XML containing a ]]> sequence inside a constraint's SQL must still be well-formed",
505        );
506        let reparsed_table = reparsed.default_schema().get_table("t");
507        assert_eq!(reparsed_table.constraints()[0].sql(), "check (a[1:2]]>0)");
508    }
509
510    #[test]
511    fn multi_line_default_expression_round_trips_through_the_real_parser() {
512        let default = "case\n\twhen a > 0 then 1\r\n  else 0\nend";
513        let table = TableBuilder::new(None::<&str>, "t")
514            .add_column(
515                ColumnBuilder::new(None::<&str>, "a", ColumnType::Int)
516                    .default_constraint(Some(default.to_string()))
517                    .build(),
518            )
519            .build();
520        let schema = SchemaBuilder::new(None::<&str>).add_table(table).build();
521        let model =
522            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
523        let xml = write_database_xml(&model).unwrap();
524
525        let reparsed = schema_parser::parse_database_xml(&xml).unwrap();
526        let column = reparsed.default_schema().get_table("t").column("a");
527        assert_eq!(column.default_constraint(), Some(default));
528    }
529
530    #[test]
531    fn omits_keys_when_no_primary_key_present() {
532        let table = TableBuilder::new(None::<&str>, "t")
533            .add_column(ColumnBuilder::new(None::<&str>, "a", ColumnType::Int).build())
534            .build();
535        let schema = SchemaBuilder::new(None::<&str>).add_table(table).build();
536        let model =
537            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
538        let xml = write_database_xml(&model).unwrap();
539        assert!(!xml.contains("<keys>"));
540    }
541
542    #[test]
543    fn pk_less_table_with_a_unique_key_is_a_hard_error() {
544        let table = TableBuilder::new(None::<&str>, "t")
545            .add_column(ColumnBuilder::new(None::<&str>, "a", ColumnType::Int).build())
546            .add_key(KeyBuilder::new(KeyType::Unique).add_column("a").build())
547            .build();
548        let schema = SchemaBuilder::new(None::<&str>).add_table(table).build();
549        let model =
550            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
551
552        let err = write_database_xml(&model).unwrap_err();
553        assert!(matches!(err, SchemaReverseEngineerError::PkLessTableHasKeys(name) if name == "t"));
554    }
555
556    #[test]
557    fn pk_less_table_with_an_index_is_a_hard_error() {
558        let table = TableBuilder::new(None::<&str>, "t")
559            .add_column(ColumnBuilder::new(None::<&str>, "a", ColumnType::Int).build())
560            .add_index(KeyBuilder::new(KeyType::Index).add_column("a").build())
561            .build();
562        let schema = SchemaBuilder::new(None::<&str>).add_table(table).build();
563        let model =
564            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
565
566        let err = write_database_xml(&model).unwrap_err();
567        assert!(matches!(err, SchemaReverseEngineerError::PkLessTableHasKeys(name) if name == "t"));
568    }
569
570    #[test]
571    fn writes_and_round_trips_a_composite_relation() {
572        let parent = TableBuilder::new(None::<&str>, "Property")
573            .add_column(
574                ColumnBuilder::new(None::<&str>, "ID", ColumnType::Sequence)
575                    .required(true)
576                    .build(),
577            )
578            .add_key(KeyBuilder::new(KeyType::Primary).add_column("ID").build())
579            .build();
580
581        let child = TableBuilder::new(None::<&str>, "Assignment")
582            .add_column(
583                ColumnBuilder::new(None::<&str>, "ID", ColumnType::Sequence)
584                    .required(true)
585                    .build(),
586            )
587            .add_column(
588                ColumnBuilder::new(None::<&str>, "PropertyID", ColumnType::Int)
589                    .required(true)
590                    .build(),
591            )
592            .add_column(
593                ColumnBuilder::new(None::<&str>, "ParentAssignmentID", ColumnType::Int).build(),
594            )
595            .add_key(KeyBuilder::new(KeyType::Primary).add_column("ID").build())
596            .add_relation(
597                Relation::new_composite(
598                    "Assignment",
599                    "Assignment",
600                    vec![("ParentAssignmentID", "ID"), ("PropertyID", "PropertyID")],
601                    RelationType::Cascade,
602                    false,
603                )
604                .unwrap(),
605            )
606            .build();
607
608        let schema = SchemaBuilder::new(None::<&str>)
609            .add_table(parent)
610            .add_table(child)
611            .build();
612        let model =
613            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
614        let xml = write_database_xml(&model).unwrap();
615
616        assert!(xml.contains("<compositeRelation table=\"Assignment\" type=\"cascade\">"));
617        assert!(xml.contains("<column src=\"ParentAssignmentID\" name=\"ID\"/>"));
618        assert!(xml.contains("<column src=\"PropertyID\" name=\"PropertyID\"/>"));
619
620        let reparsed = schema_parser::parse_database_xml(&xml)
621            .expect("round-tripped composite relation XML must be well-formed");
622        let reparsed_table = reparsed.default_schema().get_table("Assignment");
623        let relation = &reparsed_table.relations()[0];
624        assert!(relation.is_composite());
625        assert_eq!(
626            relation.column_pairs(),
627            &[
628                ("ParentAssignmentID".to_string(), "ID".to_string()),
629                ("PropertyID".to_string(), "PropertyID".to_string()),
630            ]
631        );
632    }
633
634    #[test]
635    fn wraps_tables_in_a_schema_element_when_the_schema_is_named() {
636        let table = TableBuilder::new(Some("sales"), "orders")
637            .add_column(
638                ColumnBuilder::new(Some("sales"), "id", ColumnType::Sequence)
639                    .required(true)
640                    .build(),
641            )
642            .build();
643        let schema = SchemaBuilder::new(Some("sales")).add_table(table).build();
644        let model =
645            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
646
647        let xml = write_database_xml(&model).unwrap();
648        assert!(xml.contains("<schema name=\"sales\">"));
649        assert!(xml.contains("<table name=\"orders\">"));
650        assert!(xml.contains("</schema>"));
651
652        let reparsed = schema_parser::parse_database_xml(&xml)
653            .expect("round-tripped XML must still be well-formed");
654        assert_eq!(
655            reparsed.find_schema(Some("sales")).schema_name(),
656            Some("sales")
657        );
658    }
659}