schema-sql-generator 0.6.28

A set of tools to manage relational database schemas
Documentation
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);
        }
    }

    /// Builds the constraint name for the given relation, truncating the table-name
    /// portion so the identifier stays within the target database's max key name length.
    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() {
        // Postgres caps key names at 63 chars; a long table name plus the "fk_" prefix and
        // trailing index would overflow that, so the generator must truncate the table name
        // portion rather than emit an invalid identifier.
        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)"));
        // Still the second relation, so its name keeps ordinal 2.
        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() {
        // Regression test: byte-index slicing panics ("not a char boundary") on
        // multi-byte UTF-8 once truncation kicks in; truncating by char must not.
        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_"));
        // max_key_name_length is a character budget (SQL Server identifiers are
        // nvarchar), not a byte budget, so compare char count, not `str::len()` (bytes)
        // - which would always be inflated for multi-byte UTF-8 like "语".
        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() {
        // Regression test: reserving only 1 char for the suffix (instead of measuring
        // its actual length) produced a 33-char identifier here, one over SQL Server's
        // 32-char limit, once the relation index reaches double digits.
        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);
        // relation_index 9 -> suffix "10" (double digit)
        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
        );
    }
}