schema-model 0.5.0

A set of tools to manage relational database schemas
Documentation
use crate::model::types::DatabaseType;
use std::fmt;

#[derive(Debug, Clone)]
pub struct View {
    schema_name: Option<String>,
    name: String,
    sql: String,
    database_type: Option<DatabaseType>,
}
impl View {
    pub fn new<S: Into<String>>(
        schema_name: Option<S>,
        name: S,
        sql: S,
        database_type: Option<DatabaseType>,
    ) -> Self {
        Self {
            schema_name: schema_name.map(|s| s.into()),
            name: name.into(),
            sql: sql.into(),
            database_type,
        }
    }
    pub fn schema_name(&self) -> Option<&str> {
        self.schema_name.as_deref()
    }

    pub fn name(&self) -> &str {
        &self.name
    }

    pub fn sql(&self) -> &str {
        &self.sql
    }

    pub fn database_type(&self) -> Option<DatabaseType> {
        self.database_type
    }

    pub fn fully_qualified_view_name(&self, database_type: DatabaseType) -> String {
        database_type.qualified_name(self.schema_name(), self.name())
    }
}

impl fmt::Display for View {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self.schema_name {
            Some(schema) => write!(f, "{}.{}", schema, self.name),
            None => write!(f, "{}", self.name),
        }
    }
}

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

    #[test]
    fn constructor_and_getters_and_display() {
        let v = View::new(Some("s"), "v1", "select *", Some(DatabaseType::Postgresql));
        assert_eq!(v.schema_name().unwrap(), "s");
        assert_eq!(v.name(), "v1");
        assert_eq!(v.sql(), "select *");
        assert_eq!(v.database_type().unwrap(), DatabaseType::Postgresql);
        assert_eq!(format!("{}", v), "s.v1");
    }

    #[test]
    fn fully_qualified_view_name_uses_explicit_schema() {
        let v = View::new(Some("s"), "v1", "select *", None);
        assert_eq!(v.fully_qualified_view_name(DatabaseType::Postgresql), "s.v1");
    }

    #[test]
    fn fully_qualified_view_name_falls_back_to_default_schema() {
        let v = View::new(Option::<&str>::None, "v1", "select *", None);
        assert_eq!(v.fully_qualified_view_name(DatabaseType::Postgresql), "public.v1");
        assert_eq!(v.fully_qualified_view_name(DatabaseType::SqlServer), "dbo.v1");
        assert_eq!(v.fully_qualified_view_name(DatabaseType::Sqlite), "v1");
    }
}