schema-model 0.6.3

A set of tools to manage relational database schemas
Documentation
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum DatabaseType {
    Postgresql,
    Sqlite,
    SqlServer,
}

impl DatabaseType {
    pub fn statement_separator(&self) -> &'static str {
        match self {
            DatabaseType::Postgresql => ";",
            DatabaseType::Sqlite => ";",
            DatabaseType::SqlServer => "\nGO",
        }
    }

    pub fn max_key_name_length(&self) -> usize {
        match self {
            DatabaseType::Postgresql => 63,
            DatabaseType::Sqlite => 128,
            DatabaseType::SqlServer => 32,
        }
    }

    pub fn default_schema(&self) -> Option<&'static str> {
        match self {
            DatabaseType::Postgresql => Some("public"),
            DatabaseType::SqlServer => Some("dbo"),
            DatabaseType::Sqlite => None,
        }
    }

    pub fn qualified_name(&self, schema_name: Option<&str>, name: &str) -> String {
        let resolved = match schema_name {
            Some(s) if *self == DatabaseType::SqlServer && s.eq_ignore_ascii_case("public") => Some("dbo"),
            Some(s) => Some(s),
            None => self.default_schema(),
        };
        match resolved {
            // SQLite has no schema concept - `schema.name` would be parsed as a reference to
            // an ATTACHed database named `schema`, which doesn't exist. Flatten instead, so a
            // multi-schema model still produces runnable (if less prettily namespaced) SQLite
            // output.
            Some(schema) if *self == DatabaseType::Sqlite => format!("{}_{}", schema, name),
            Some(schema) => format!("{}.{}", schema, name),
            None => name.to_string(),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum RelationType {
    Cascade,
    Enforce,
    SetNull,
    DoNothing,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[derive(Default)]
pub enum BooleanMode {
    #[default]
    Native,
    YesNo,
    YN,
}


impl FromStr for BooleanMode {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "native" => Ok(BooleanMode::Native),
            "yesno" => Ok(BooleanMode::YesNo),
            "yn" => Ok(BooleanMode::YN),
            _ => Err(format!("Unknown boolean mode: {}", s)),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[derive(Default)]
pub enum ForeignKeyMode {
    None,
    #[default]
    Relations,
    Triggers,
}


impl FromStr for ForeignKeyMode {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "none" => Ok(ForeignKeyMode::None),
            "relations" => Ok(ForeignKeyMode::Relations),
            "triggers" => Ok(ForeignKeyMode::Triggers),
            _ => Err(format!("Unknown foreign key mode: {}", s)),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum OtherSqlOrder {
    Bottom,
    Top,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum TableOption {
    Data,
    NoExport,
    Compress,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum TriggerType {
    Update,
    Delete,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum KeyType {
    Primary,
    Unique,
    Index,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[derive(Default)]
pub enum LockEscalation {
    #[default]
    Auto,
    Disable,
    Table,
}


impl FromStr for LockEscalation {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "auto" => Ok(LockEscalation::Auto),
            "disable" => Ok(LockEscalation::Disable),
            "table" => Ok(LockEscalation::Table),
            _ => Err(format!("Unknown lock escalation: {}", s)),
        }
    }
}

use std::str::FromStr;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn boolean_mode_default_is_native() {
        let bm = BooleanMode::default();
        assert_eq!(bm, BooleanMode::Native);
    }

    #[test]
    fn enums_equality_and_copy() {
        let db: DatabaseType = DatabaseType::Postgresql;
        let db2 = db;
        assert_eq!(db, db2);

        let t1 = TriggerType::Update;
        let t2 = TriggerType::Update;
        assert_eq!(t1, t2);

        let rel = RelationType::Cascade;
        assert_eq!(rel, RelationType::Cascade);

        let k = KeyType::Primary;
        assert_eq!(k, KeyType::Primary);

        let fk = ForeignKeyMode::Relations;
        assert_eq!(fk, ForeignKeyMode::Relations);

        let ord = OtherSqlOrder::Top;
        assert_eq!(ord, OtherSqlOrder::Top);

        let le = LockEscalation::Auto;
        assert_eq!(le, LockEscalation::Auto);
    }

    #[test]
    fn table_option_equality() {
        assert_eq!(TableOption::Compress, TableOption::Compress);
        assert_ne!(TableOption::Data, TableOption::NoExport);
    }

    #[test]
    fn default_schema_per_database_type() {
        assert_eq!(DatabaseType::Postgresql.default_schema(), Some("public"));
        assert_eq!(DatabaseType::SqlServer.default_schema(), Some("dbo"));
        assert_eq!(DatabaseType::Sqlite.default_schema(), None);
    }

    #[test]
    fn qualified_name_uses_default_schema_when_none() {
        assert_eq!(DatabaseType::Postgresql.qualified_name(None, "users"), "public.users");
        assert_eq!(DatabaseType::SqlServer.qualified_name(None, "users"), "dbo.users");
        assert_eq!(DatabaseType::Sqlite.qualified_name(None, "users"), "users");
    }

    #[test]
    fn qualified_name_preserves_explicit_non_default_schema() {
        assert_eq!(DatabaseType::Postgresql.qualified_name(Some("app"), "users"), "app.users");
        assert_eq!(DatabaseType::SqlServer.qualified_name(Some("app"), "users"), "app.users");
    }

    #[test]
    fn qualified_name_flattens_schema_for_sqlite() {
        // SQLite has no schema concept - `app.users` would be parsed as a reference to an
        // ATTACHed database named `app`. Flatten to `app_users` instead of emitting SQL that
        // can never execute.
        assert_eq!(DatabaseType::Sqlite.qualified_name(Some("app"), "users"), "app_users");
        assert_eq!(DatabaseType::Sqlite.qualified_name(None, "users"), "users");
    }

    #[test]
    fn qualified_name_maps_public_to_dbo_on_sql_server() {
        assert_eq!(DatabaseType::SqlServer.qualified_name(Some("public"), "users"), "dbo.users");
        assert_eq!(DatabaseType::SqlServer.qualified_name(Some("PUBLIC"), "users"), "dbo.users");
        assert_eq!(DatabaseType::Postgresql.qualified_name(Some("public"), "users"), "public.users");
    }
}