use crate::common::generator_context::GeneratorContext;
use crate::common::sql_writer::SqlWriter;
use schema_model::model::database_model::DatabaseModel;
use schema_model::model::relation::Relation;
use schema_model::model::table::Table;
use schema_model::model::types::RelationType;
use schema_model::naming::foreign_key_name;
pub trait RelationGenerator {
fn output_relations(&self);
}
fn has_foreign_key_relations(table: &&Table) -> bool {
table
.relations()
.iter()
.any(Relation::creates_foreign_key_constraint)
}
pub struct DefaultRelationGenerator {
context: GeneratorContext,
}
impl DefaultRelationGenerator {
pub fn new(context: GeneratorContext) -> Self {
Self { context }
}
pub fn context(&self) -> &GeneratorContext {
&self.context
}
fn output_relation_for_table(&self, writer: &mut SqlWriter, table: &Table) {
let database_model = self.context.settings().database_model();
for (relation_index, relation) in table.relations().iter().enumerate() {
if !relation.creates_foreign_key_constraint() {
continue;
}
let relation_name = self.relation_constraint_name(table, relation_index);
self.output_relation(writer, &relation_name, database_model, table, relation);
}
}
pub fn relation_constraint_name(&self, table: &Table, relation_index: usize) -> String {
let database_type = self.context.settings().database_type();
foreign_key_name(database_type, table.name(), relation_index + 1)
}
fn output_relation(
&self,
writer: &mut SqlWriter,
relation_name: &str,
database_model: &DatabaseModel,
table: &Table,
relation: &Relation,
) {
let operation = self.relation_operation_type(relation.relation_type());
let database_type = self.context.settings().database_type();
let to_table = database_model.find_table_by_qualified_name(relation.to_table_name());
let from_columns = relation
.column_pairs()
.iter()
.map(|(from, _)| from.as_str())
.collect::<Vec<_>>()
.join(", ");
let to_columns = relation
.column_pairs()
.iter()
.map(|(_, to)| to.as_str())
.collect::<Vec<_>>()
.join(", ");
writer.print(
format!(
"alter table {}",
table.fully_qualified_table_name(database_type)
)
.as_str(),
);
writer.print(" add constraint ");
writer.print(relation_name);
writer.print(" foreign key (");
writer.print(from_columns.as_str());
writer.print(") references ");
writer.print(to_table.fully_qualified_table_name(database_type).as_str());
writer.print("(");
writer.print(to_columns.as_str());
writer.print(") on delete ");
writer.print(operation);
writer.println(self.context().settings().statement_separator());
}
pub fn relation_operation_type(&self, relation_type: RelationType) -> &str {
match relation_type {
RelationType::Cascade => "cascade",
RelationType::Enforce => "no action",
RelationType::SetNull => "set null",
RelationType::DoNothing => "no action",
}
}
}
impl RelationGenerator for DefaultRelationGenerator {
fn output_relations(&self) {
let database_model = self.context.settings().database_model();
let has_relations = database_model
.all_tables()
.iter()
.any(has_foreign_key_relations);
if has_relations {
self.context.with_writer(|writer| {
writer.println("/* relations */");
database_model
.all_tables()
.iter()
.filter(|table| has_foreign_key_relations(table))
.for_each(|table| {
self.output_relation_for_table(writer, table);
});
writer.newline();
});
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::common::test_support::make_context;
use schema_model::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
use schema_model::model::column_type::ColumnType;
use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
#[test]
fn output_relations_truncates_generated_constraint_name_for_long_table_names() {
let long_table_name = "a".repeat(70);
let parent = TableBuilder::new(None::<&str>, "parent")
.add_column(
ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
.required(true)
.build(),
)
.build();
let child = TableBuilder::new(None::<&str>, long_table_name.as_str())
.add_column(
ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int)
.required(true)
.build(),
)
.add_relation(Relation::new(
"parent",
"id",
long_table_name.as_str(),
"parent_id",
RelationType::Cascade,
false,
))
.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 (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
let generator = DefaultRelationGenerator::new(ctx);
generator.output_relations();
let output = buffer.contents();
assert!(output.contains("add constraint "));
let constraint_start = output.find("add constraint ").unwrap() + "add constraint ".len();
let constraint_name = &output[constraint_start..]
.split_whitespace()
.next()
.unwrap();
assert!(
constraint_name.len() <= 63,
"constraint name '{}' exceeds postgres's 63 char limit",
constraint_name
);
}
#[test]
fn output_relations_skips_donothing_relations_but_keeps_ordinals_stable() {
let parent = TableBuilder::new(None::<&str>, "parent")
.add_column(
ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
.required(true)
.build(),
)
.build();
let child = TableBuilder::new(None::<&str>, "child")
.add_column(ColumnBuilder::new(None::<&str>, "a_id", ColumnType::Int).build())
.add_column(ColumnBuilder::new(None::<&str>, "b_id", ColumnType::Int).build())
.add_relation(Relation::new(
"parent",
"id",
"child",
"a_id",
RelationType::DoNothing,
false,
))
.add_relation(Relation::new(
"parent",
"id",
"child",
"b_id",
RelationType::Enforce,
false,
))
.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 (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
DefaultRelationGenerator::new(ctx).output_relations();
let output = buffer.contents();
assert!(
!output.contains("a_id"),
"donothing relation must emit no constraint: {output}"
);
assert!(output.contains("foreign key (b_id)"));
assert!(output.contains("fk_child2"), "{output}");
}
#[test]
fn output_relations_emits_nothing_when_every_relation_is_donothing() {
let parent = TableBuilder::new(None::<&str>, "parent")
.add_column(
ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
.required(true)
.build(),
)
.build();
let child = TableBuilder::new(None::<&str>, "child")
.add_column(ColumnBuilder::new(None::<&str>, "a_id", ColumnType::Int).build())
.add_relation(Relation::new(
"parent",
"id",
"child",
"a_id",
RelationType::DoNothing,
false,
))
.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 (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
DefaultRelationGenerator::new(ctx).output_relations();
assert_eq!(buffer.contents(), "");
}
#[test]
fn relation_constraint_name_truncates_multi_byte_table_name_without_panicking() {
let long_table_name = "语".repeat(70);
let table = TableBuilder::new(None::<&str>, long_table_name.as_str()).build();
let schema = SchemaBuilder::new(None::<&str>)
.add_table(table.clone())
.build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
let generator = DefaultRelationGenerator::new(ctx);
let name = generator.relation_constraint_name(&table, 0);
assert!(name.starts_with("fk_"));
assert!(name.chars().count() <= 32);
}
#[test]
fn output_relations_renders_composite_foreign_key_constraint() {
let parent = TableBuilder::new(None::<&str>, "parent")
.add_column(
ColumnBuilder::new(None::<&str>, "id", ColumnType::Sequence)
.required(true)
.build(),
)
.add_column(
ColumnBuilder::new(None::<&str>, "tenant_id", ColumnType::Int)
.required(true)
.build(),
)
.build();
let child = TableBuilder::new(None::<&str>, "child")
.add_column(
ColumnBuilder::new(None::<&str>, "parent_id", ColumnType::Int)
.required(true)
.build(),
)
.add_column(
ColumnBuilder::new(None::<&str>, "tenant_id", ColumnType::Int)
.required(true)
.build(),
)
.add_relation(
Relation::new_composite(
"parent",
"child",
vec![("parent_id", "id"), ("tenant_id", "tenant_id")],
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 (ctx, buffer) = make_context(model, DatabaseType::Postgresql);
let generator = DefaultRelationGenerator::new(ctx);
generator.output_relations();
let output = buffer.contents();
assert!(
output.contains(
"foreign key (parent_id, tenant_id) references public.parent(id, tenant_id)"
),
"unexpected output: {output}"
);
}
#[test]
fn relation_constraint_name_stays_within_limit_for_double_digit_relation_index() {
let long_table_name = "a".repeat(40);
let table = TableBuilder::new(None::<&str>, long_table_name.as_str()).build();
let schema = SchemaBuilder::new(None::<&str>)
.add_table(table.clone())
.build();
let model =
DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
let (ctx, _buffer) = make_context(model, DatabaseType::SqlServer);
let generator = DefaultRelationGenerator::new(ctx);
let name = generator.relation_constraint_name(&table, 9);
assert!(name.ends_with("10"));
assert!(
name.len() <= 32,
"constraint name '{}' exceeds SQL Server's 32 char limit",
name
);
}
}