use schema_model::model::column::Column;
use schema_model::model::constraint::Constraint;
use schema_model::model::database_model::DatabaseModel;
use schema_model::model::enum_type::EnumType;
use schema_model::model::key::Key;
use schema_model::model::relation::Relation;
use schema_model::model::schema::Schema;
use schema_model::model::table::Table;
use schema_model::model::types::{
BooleanMode, DatabaseType, ForeignKeyMode, KeyType, OtherSqlOrder,
};
use schema_model::model::view::View;
use std::fmt::Write as _;
const NAMESPACE: &str = "http://stano.com/database";
pub fn write_database_xml(model: &DatabaseModel) -> String {
let mut out = String::new();
out.push_str("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
let _ = writeln!(
out,
"<database xmlns=\"{}\" foreignKeyMode=\"{}\" booleanMode=\"{}\">",
NAMESPACE,
foreign_key_mode_str(model.foreign_key_mode()),
boolean_mode_str(model.boolean_mode())
);
for schema in model.schemas() {
match schema.schema_name() {
Some(name) => {
push_indent(&mut out, 1);
let _ = writeln!(out, "<schema name=\"{}\">", xml_escape_attr(name));
write_schema_body(&mut out, schema, 2);
push_indent(&mut out, 1);
out.push_str("</schema>\n");
}
None => write_schema_body(&mut out, schema, 1),
}
}
out.push_str("</database>\n");
out
}
fn write_schema_body(out: &mut String, schema: &Schema, indent: usize) {
for enum_type in schema.enum_types() {
write_enum(out, enum_type, indent);
}
for table in schema.tables() {
write_table(out, table, indent);
}
for view in schema.all_views() {
write_view(out, view, indent);
}
for function in schema.functions() {
write_routine(
out,
"function",
function.name(),
function.database_type(),
function.sql(),
indent,
);
}
for procedure in schema.procedures() {
write_routine(
out,
"procedure",
procedure.name(),
procedure.database_type(),
procedure.sql(),
indent,
);
}
for other in schema.other_sql() {
push_indent(out, indent);
let _ = write!(
out,
"<otherSql databaseType=\"{}\" order=\"{}\">",
database_type_str(other.database_type()),
match other.order() {
OtherSqlOrder::Top => "top",
OtherSqlOrder::Bottom => "bottom",
}
);
write_cdata(out, other.sql());
out.push_str("</otherSql>\n\n");
}
}
fn write_routine(
out: &mut String,
tag: &str,
name: &str,
database_type: DatabaseType,
sql: &str,
indent: usize,
) {
push_indent(out, indent);
let _ = writeln!(out, "<{} name=\"{}\">", tag, xml_escape_attr(name));
push_indent(out, indent + 1);
let _ = write!(
out,
"<sql databaseType=\"{}\">",
database_type_str(database_type)
);
write_cdata(out, sql);
out.push_str("</sql>\n");
push_indent(out, indent);
let _ = writeln!(out, "</{}>\n", tag);
}
fn write_enum(out: &mut String, enum_type: &EnumType, indent: usize) {
push_indent(out, indent);
let _ = writeln!(out, "<enum name=\"{}\">", xml_escape_attr(enum_type.name()));
for value in enum_type.values() {
push_indent(out, indent + 1);
let _ = write!(out, "<value name=\"{}\"", xml_escape_attr(value.name()));
if value.code() != value.name() {
let _ = write!(out, " code=\"{}\"", xml_escape_attr(value.code()));
}
out.push_str("/>\n");
}
push_indent(out, indent);
out.push_str("</enum>\n\n");
}
fn write_view(out: &mut String, view: &View, indent: usize) {
push_indent(out, indent);
let _ = writeln!(out, "<view name=\"{}\">", xml_escape_attr(view.name()));
push_indent(out, indent + 1);
write_cdata(out, view.sql());
out.push('\n');
push_indent(out, indent);
out.push_str("</view>\n\n");
}
fn write_table(out: &mut String, table: &Table, indent: usize) {
push_indent(out, indent);
let _ = writeln!(out, "<table name=\"{}\">", xml_escape_attr(table.name()));
write_columns(out, table.columns(), indent + 1);
write_keys(out, table, indent + 1);
write_relations(out, table.relations(), table.schema_name(), indent + 1);
write_constraints(out, table.constraints(), indent + 1);
push_indent(out, indent);
out.push_str("</table>\n\n");
}
fn write_columns(out: &mut String, columns: &[Column], indent: usize) {
push_indent(out, indent);
out.push_str("<columns>\n");
for column in columns {
write_column(out, column, indent + 1);
}
push_indent(out, indent);
out.push_str("</columns>\n");
}
fn write_column(out: &mut String, column: &Column, indent: usize) {
push_indent(out, indent);
let _ = write!(
out,
"<column name=\"{}\" type=\"{}\"",
xml_escape_attr(column.name()),
column.column_type().name().to_lowercase()
);
if column.length() > 0 {
let _ = write!(out, " length=\"{}\"", column.length());
}
if column.scale() > 0 {
let _ = write!(out, " scale=\"{}\"", column.scale());
}
if column.required() {
out.push_str(" required=\"true\"");
}
if let Some(default) = column.default_constraint() {
let _ = write!(out, " default=\"{}\"", xml_escape_attr(default));
}
if let Some(generated) = column.generated() {
let _ = write!(out, " generated=\"{}\"", xml_escape_attr(generated));
}
if let Some(enum_type) = column.enum_type() {
let _ = write!(out, " enumType=\"{}\"", xml_escape_attr(enum_type));
}
if let Some(element_type) = column.element_type() {
let _ = write!(out, " elementType=\"{}\"", xml_escape_attr(element_type));
}
if let Some(min_value) = column.min_value() {
let _ = write!(out, " minValue=\"{}\"", min_value);
}
if let Some(max_value) = column.max_value() {
let _ = write!(out, " maxValue=\"{}\"", max_value);
}
let database_checks: Vec<(DatabaseType, &str)> = [
DatabaseType::Postgresql,
DatabaseType::Sqlite,
DatabaseType::SqlServer,
]
.into_iter()
.filter_map(|t| column.database_checks().get(&t).map(|c| (t, c.as_str())))
.collect();
if column.check_constraint().is_some() || !database_checks.is_empty() {
out.push_str(">\n");
if let Some(check) = column.check_constraint() {
push_indent(out, indent + 1);
let _ = writeln!(out, "<check>{}</check>", xml_escape(check));
}
for (database_type, check) in database_checks {
push_indent(out, indent + 1);
let _ = writeln!(
out,
"<check databaseType=\"{}\">{}</check>",
database_type_str(database_type),
xml_escape(check)
);
}
push_indent(out, indent);
out.push_str("</column>\n");
} else {
out.push_str("/>\n");
}
}
fn write_keys(out: &mut String, table: &Table, indent: usize) {
let uniques: Vec<&Key> = table
.keys()
.iter()
.filter(|k| k.key_type() == KeyType::Unique)
.collect();
let primary = table.primary_key();
if primary.is_none() && uniques.is_empty() && table.indexes().is_empty() {
return;
}
push_indent(out, indent);
out.push_str("<keys>\n");
if let Some(primary) = primary {
write_key_columns(out, "primary", primary, indent + 1);
}
for unique in uniques {
write_key_columns(out, "unique", unique, indent + 1);
}
for index in table.indexes() {
write_index(out, index, indent + 1);
}
push_indent(out, indent);
out.push_str("</keys>\n");
}
fn write_key_columns(out: &mut String, tag: &str, key: &Key, indent: usize) {
push_indent(out, indent);
let _ = writeln!(out, "<{}>", tag);
for column in key.columns() {
push_indent(out, indent + 1);
let _ = writeln!(out, "<column name=\"{}\"/>", xml_escape_attr(column.name()));
}
push_indent(out, indent);
let _ = writeln!(out, "</{}>", tag);
}
fn write_index(out: &mut String, index: &Key, indent: usize) {
push_indent(out, indent);
let _ = write!(out, "<index");
if index.is_unique() {
out.push_str(" unique=\"true\"");
}
if let Some(include) = index.include() {
let _ = write!(out, " include=\"{}\"", xml_escape_attr(include));
}
if let Some(filter) = index.filter() {
let _ = write!(out, " where=\"{}\"", xml_escape_attr(filter));
}
out.push_str(">\n");
for column in index.columns() {
push_indent(out, indent + 1);
let _ = writeln!(out, "<column name=\"{}\"/>", xml_escape_attr(column.name()));
}
push_indent(out, indent);
out.push_str("</index>\n");
}
fn write_relations(
out: &mut String,
relations: &[Relation],
schema_name: Option<&str>,
indent: usize,
) {
let target = |table: &str| match schema_name {
Some(schema) if !table.contains('.') => format!("{schema}.{table}"),
_ => table.to_string(),
};
if relations.is_empty() {
return;
}
push_indent(out, indent);
out.push_str("<relations>\n");
for relation in relations {
if relation.is_composite() {
push_indent(out, indent + 1);
let _ = writeln!(
out,
"<compositeRelation table=\"{}\" type=\"{}\">",
xml_escape_attr(&target(relation.to_table_name())),
relation_type_str(relation.relation_type())
);
for (from_column, to_column) in relation.column_pairs() {
push_indent(out, indent + 2);
let _ = writeln!(
out,
"<column src=\"{}\" name=\"{}\"/>",
xml_escape_attr(from_column),
xml_escape_attr(to_column)
);
}
push_indent(out, indent + 1);
out.push_str("</compositeRelation>\n");
} else {
push_indent(out, indent + 1);
let _ = writeln!(
out,
"<relation src=\"{}\" table=\"{}\" column=\"{}\" type=\"{}\"/>",
xml_escape_attr(relation.from_column_name()),
xml_escape_attr(&target(relation.to_table_name())),
xml_escape_attr(relation.to_column_name()),
relation_type_str(relation.relation_type())
);
}
}
push_indent(out, indent);
out.push_str("</relations>\n");
}
fn write_constraints(out: &mut String, constraints: &[Constraint], indent: usize) {
if constraints.is_empty() {
return;
}
push_indent(out, indent);
out.push_str("<constraints>\n");
for constraint in constraints {
push_indent(out, indent + 1);
let database_type_attr = constraint
.database_type()
.map(|d| format!(" databaseType=\"{}\"", database_type_str(d)))
.unwrap_or_default();
let _ = writeln!(
out,
"<constraint name=\"{}\"{}>",
xml_escape_attr(constraint.name()),
database_type_attr
);
push_indent(out, indent + 2);
write_cdata(out, constraint.sql());
out.push('\n');
push_indent(out, indent + 1);
out.push_str("</constraint>\n");
}
push_indent(out, indent);
out.push_str("</constraints>\n");
}
fn relation_type_str(relation_type: schema_model::model::types::RelationType) -> &'static str {
use schema_model::model::types::RelationType;
match relation_type {
RelationType::Cascade => "cascade",
RelationType::Enforce => "enforce",
RelationType::SetNull => "setnull",
RelationType::DoNothing => "donothing",
}
}
fn boolean_mode_str(mode: BooleanMode) -> &'static str {
match mode {
BooleanMode::Native => "native",
BooleanMode::YesNo => "yesno",
BooleanMode::YN => "yn",
}
}
fn database_type_str(database_type: schema_model::model::types::DatabaseType) -> &'static str {
use schema_model::model::types::DatabaseType;
match database_type {
DatabaseType::Postgresql => "postgresql",
DatabaseType::Sqlite => "sqlite",
DatabaseType::SqlServer => "sqlserver",
}
}
fn foreign_key_mode_str(mode: ForeignKeyMode) -> &'static str {
match mode {
ForeignKeyMode::None => "none",
ForeignKeyMode::Relations => "relations",
ForeignKeyMode::Triggers => "triggers",
}
}
fn push_indent(out: &mut String, indent: usize) {
for _ in 0..indent {
out.push_str(" ");
}
}
fn write_cdata(out: &mut String, content: &str) {
out.push_str("<![CDATA[");
out.push_str(&content.replace("]]>", "]]]]><![CDATA[>"));
out.push_str("]]>");
}
fn xml_escape(value: &str) -> String {
let mut escaped = String::with_capacity(value.len());
for ch in value.chars() {
match ch {
'&' => escaped.push_str("&"),
'<' => escaped.push_str("<"),
'>' => escaped.push_str(">"),
'"' => escaped.push_str("""),
'\'' => escaped.push_str("'"),
_ => escaped.push(ch),
}
}
escaped
}
fn xml_escape_attr(value: &str) -> String {
let mut escaped = String::with_capacity(value.len());
for ch in xml_escape(value).chars() {
match ch {
'\n' => escaped.push_str(" "),
'\r' => escaped.push_str(" "),
'\t' => escaped.push_str("	"),
_ => escaped.push(ch),
}
}
escaped
}
#[cfg(test)]
mod tests {
use super::*;
use schema_model::builder::{ColumnBuilder, KeyBuilder, SchemaBuilder, TableBuilder};
use schema_model::model::column_type::ColumnType;
use schema_model::model::enum_type::EnumValue;
use schema_model::model::relation::Relation;
use schema_model::model::types::{DatabaseType, RelationType};
#[test]
fn writes_table_with_columns_pk_and_relation() {
let parent = TableBuilder::new(None::<&str>, "parent")
.add_column(
ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
.required(true)
.build(),
)
.add_key(KeyBuilder::new(KeyType::Primary).add_column("id").build())
.build();
let child = TableBuilder::new(None::<&str>, "child")
.add_column(
ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
.required(true)
.build(),
)
.add_column(
ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int)
.required(true)
.build(),
)
.add_key(KeyBuilder::new(KeyType::Primary).add_column("id").build())
.add_relation(Relation::new(
"parent",
"id",
"child",
"parent_id",
RelationType::Cascade,
false,
))
.build();
let schema = SchemaBuilder::new(None::<&str>)
.add_table(parent)
.add_table(child)
.add_enum_type(EnumType::new(
"mood",
vec![EnumValue::new("HAPPY", None::<String>)],
))
.add_view(View::new(
None::<&str>,
"v1",
"select 1",
Some(DatabaseType::Postgresql),
))
.build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let xml = write_database_xml(&model);
assert!(xml.contains("<database xmlns=\"http://stano.com/database\""));
assert!(xml.contains("<table name=\"parent\">"));
assert!(xml.contains("<column name=\"id\" type=\"sequence\" required=\"true\"/>"));
assert!(xml.contains(
"<relation src=\"parent_id\" table=\"parent\" column=\"id\" type=\"cascade\"/>"
));
assert!(xml.contains("<enum name=\"mood\">"));
assert!(xml.contains("<view name=\"v1\">"));
}
#[test]
fn write_cdata_splits_embedded_close_sequence() {
let mut out = String::new();
write_cdata(&mut out, "select arr[1:2]]>x from t");
assert!(
!out.contains("2]]>x"),
"the literal ]]> must not survive unescaped inside one CDATA block: {out}"
);
assert!(out.starts_with("<![CDATA["));
assert!(out.ends_with("]]>"));
}
#[test]
fn view_sql_containing_cdata_close_sequence_round_trips_through_the_real_parser() {
let view = View::new(
None::<&str>,
"v1",
"select * from t where arr[1:2]]>x",
None,
);
let schema = SchemaBuilder::new(None::<&str>).add_view(view).build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let xml = write_database_xml(&model);
let reparsed = schema_parser::parse_database_xml(&xml)
.expect("XML containing a ]]> sequence inside a view's SQL must still be well-formed");
let reparsed_view = &reparsed.default_schema().all_views()[0];
assert_eq!(reparsed_view.sql(), "select * from t where arr[1:2]]>x");
}
#[test]
fn other_sql_round_trips_through_the_real_parser() {
use schema_model::model::other_sql::OtherSql;
let schema = SchemaBuilder::new(None::<&str>)
.add_other_sql(OtherSql::new(
DatabaseType::SqlServer,
OtherSqlOrder::Bottom,
"create trigger trg on t after insert as select 1 where 'a]]>b' = 'x'",
))
.build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let xml = write_database_xml(&model);
let reparsed = schema_parser::parse_database_xml(&xml).expect("otherSql must be valid XML");
let other = &reparsed.default_schema().other_sql()[0];
assert_eq!(other.database_type(), DatabaseType::SqlServer);
assert_eq!(other.order(), OtherSqlOrder::Bottom);
assert!(other.sql().contains("a]]>b"));
}
#[test]
fn functions_and_procedures_round_trip_through_the_real_parser() {
use schema_model::model::function::Function;
use schema_model::model::procedure::Procedure;
let schema = SchemaBuilder::new(None::<&str>)
.add_functions(vec![Function::new(
None,
"f1",
DatabaseType::Postgresql,
"create or replace function f1() returns int as $$ select arr[1:2]]>1 $$",
)])
.add_procedures(vec![Procedure::new(
None,
"p1",
DatabaseType::Postgresql,
"create or replace procedure p1() language sql as $$ select 1 $$",
)])
.build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let xml = write_database_xml(&model);
let reparsed = schema_parser::parse_database_xml(&xml).expect("routines must be valid XML");
let default_schema = reparsed.default_schema();
assert_eq!(default_schema.functions()[0].name(), "f1");
assert!(default_schema.functions()[0].sql().contains("arr[1:2]]>1"));
assert_eq!(
default_schema.functions()[0].database_type(),
DatabaseType::Postgresql
);
assert_eq!(default_schema.procedures()[0].name(), "p1");
}
#[test]
fn portable_constraint_round_trips_without_a_database_type() {
let table = TableBuilder::new(None::<&str>, "t")
.add_column(ColumnBuilder::new(None::<&str>, "a", ColumnType::Int).build())
.add_constraint(
schema_model::model::constraint::Constraint::for_every_database(
"ck_a",
"check (a>0)",
),
)
.build();
let schema = SchemaBuilder::new(None::<&str>).add_table(table).build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let xml = write_database_xml(&model);
assert!(!xml.contains("databaseType"), "{xml}");
let reparsed = schema_parser::parse_database_xml(&xml).expect("valid XML");
let constraint = &reparsed.default_schema().get_table("t").constraints()[0];
assert_eq!(constraint.database_type(), None);
}
#[test]
fn constraint_sql_containing_cdata_close_sequence_round_trips_through_the_real_parser() {
let table = TableBuilder::new(None::<&str>, "t")
.add_column(ColumnBuilder::new(None::<&str>, "a", ColumnType::Int).build())
.add_constraint(schema_model::model::constraint::Constraint::new(
"ck_a",
"check (a[1:2]]>0)",
DatabaseType::Postgresql,
))
.build();
let schema = SchemaBuilder::new(None::<&str>).add_table(table).build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let xml = write_database_xml(&model);
let reparsed = schema_parser::parse_database_xml(&xml).expect(
"XML containing a ]]> sequence inside a constraint's SQL must still be well-formed",
);
let reparsed_table = reparsed.default_schema().get_table("t");
assert_eq!(reparsed_table.constraints()[0].sql(), "check (a[1:2]]>0)");
}
#[test]
fn multi_line_default_expression_round_trips_through_the_real_parser() {
let default = "case\n\twhen a > 0 then 1\r\n else 0\nend";
let table = TableBuilder::new(None::<&str>, "t")
.add_column(
ColumnBuilder::new(None::<&str>, "a", ColumnType::Int)
.default_constraint(Some(default.to_string()))
.build(),
)
.build();
let schema = SchemaBuilder::new(None::<&str>).add_table(table).build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let xml = write_database_xml(&model);
let reparsed = schema_parser::parse_database_xml(&xml).unwrap();
let column = reparsed.default_schema().get_table("t").column("a");
assert_eq!(column.default_constraint(), Some(default));
}
#[test]
fn omits_keys_when_no_primary_key_present() {
let table = TableBuilder::new(None::<&str>, "t")
.add_column(ColumnBuilder::new(None::<&str>, "a", ColumnType::Int).build())
.build();
let schema = SchemaBuilder::new(None::<&str>).add_table(table).build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let xml = write_database_xml(&model);
assert!(!xml.contains("<keys>"));
}
#[test]
fn pk_less_table_keys_and_indexes_are_written() {
let table = TableBuilder::new(None::<&str>, "t")
.add_column(ColumnBuilder::new(None::<&str>, "a", ColumnType::Int).build())
.add_key(KeyBuilder::new(KeyType::Unique).add_column("a").build())
.add_index(KeyBuilder::new(KeyType::Index).add_column("a").build())
.build();
let schema = SchemaBuilder::new(None::<&str>).add_table(table).build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let xml = write_database_xml(&model);
assert!(xml.contains("<keys>"), "got: {xml}");
assert!(!xml.contains("<primary>"), "got: {xml}");
let reparsed = schema_parser::parse_database_xml(&xml).unwrap();
let t = reparsed.default_schema().get_table("t");
assert!(t.primary_key().is_none());
assert_eq!(t.keys().len(), 1);
assert_eq!(t.indexes().len(), 1);
}
#[test]
fn database_specific_checks_round_trip() {
let table = TableBuilder::new(None::<&str>, "t")
.add_column(
ColumnBuilder::new(None::<&str>, "a", ColumnType::Int)
.check_constraint(Some("a > 0".to_string()))
.database_check(DatabaseType::SqlServer, "a > 2".to_string())
.database_check(DatabaseType::Postgresql, "a > 1".to_string())
.build(),
)
.build();
let schema = SchemaBuilder::new(None::<&str>).add_table(table).build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let xml = write_database_xml(&model);
assert!(
xml.contains("<check databaseType=\"postgresql\">a > 1</check>"),
"got: {xml}"
);
let reparsed = schema_parser::parse_database_xml(&xml).unwrap();
let a = reparsed.default_schema().get_table("t").column("a").clone();
assert_eq!(a.check_constraint(), Some("a > 0"));
assert_eq!(
a.check_constraint_for(DatabaseType::Postgresql),
Some("a > 1")
);
assert_eq!(
a.check_constraint_for(DatabaseType::SqlServer),
Some("a > 2")
);
}
#[test]
fn writes_and_round_trips_a_composite_relation() {
let parent = TableBuilder::new(None::<&str>, "Property")
.add_column(
ColumnBuilder::new(None::<&str>, "ID", ColumnType::Sequence)
.required(true)
.build(),
)
.add_key(KeyBuilder::new(KeyType::Primary).add_column("ID").build())
.build();
let child = TableBuilder::new(None::<&str>, "Assignment")
.add_column(
ColumnBuilder::new(None::<&str>, "ID", ColumnType::Sequence)
.required(true)
.build(),
)
.add_column(
ColumnBuilder::new(None::<&str>, "PropertyID", ColumnType::Int)
.required(true)
.build(),
)
.add_column(
ColumnBuilder::new(None::<&str>, "ParentAssignmentID", ColumnType::Int).build(),
)
.add_key(KeyBuilder::new(KeyType::Primary).add_column("ID").build())
.add_relation(
Relation::new_composite(
"Assignment",
"Assignment",
vec![("ParentAssignmentID", "ID"), ("PropertyID", "PropertyID")],
RelationType::Cascade,
false,
)
.unwrap(),
)
.build();
let schema = SchemaBuilder::new(None::<&str>)
.add_table(parent)
.add_table(child)
.build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let xml = write_database_xml(&model);
assert!(xml.contains("<compositeRelation table=\"Assignment\" type=\"cascade\">"));
assert!(xml.contains("<column src=\"ParentAssignmentID\" name=\"ID\"/>"));
assert!(xml.contains("<column src=\"PropertyID\" name=\"PropertyID\"/>"));
let reparsed = schema_parser::parse_database_xml(&xml)
.expect("round-tripped composite relation XML must be well-formed");
let reparsed_table = reparsed.default_schema().get_table("Assignment");
let relation = &reparsed_table.relations()[0];
assert!(relation.is_composite());
assert_eq!(
relation.column_pairs(),
&[
("ParentAssignmentID".to_string(), "ID".to_string()),
("PropertyID".to_string(), "PropertyID".to_string()),
]
);
}
#[test]
fn wraps_tables_in_a_schema_element_when_the_schema_is_named() {
let table = TableBuilder::new(Some("sales"), "orders")
.add_column(
ColumnBuilder::new(Some("sales"), "id", ColumnType::Sequence)
.required(true)
.build(),
)
.build();
let schema = SchemaBuilder::new(Some("sales")).add_table(table).build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let xml = write_database_xml(&model);
assert!(xml.contains("<schema name=\"sales\">"));
assert!(xml.contains("<table name=\"orders\">"));
assert!(xml.contains("</schema>"));
let reparsed = schema_parser::parse_database_xml(&xml)
.expect("round-tripped XML must still be well-formed");
assert_eq!(
reparsed.find_schema(Some("sales")).schema_name(),
Some("sales")
);
}
}