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
16pub 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 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
340fn 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
351fn 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("&"),
359 '<' => escaped.push_str("<"),
360 '>' => escaped.push_str(">"),
361 '"' => escaped.push_str("""),
362 '\'' => escaped.push_str("'"),
363 _ => escaped.push(ch),
364 }
365 }
366 escaped
367}
368
369fn 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(" "),
378 '\r' => escaped.push_str(" "),
379 '\t' => escaped.push_str("	"),
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}