Skip to main content

schema_sql_generator/common/
sql_generator_settings.rs

1use crate::common::generate_options::GenerateOptions;
2use crate::common::output_mode::OutputMode;
3use schema_model::model::database_model::DatabaseModel;
4use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
5use std::rc::Rc;
6
7#[derive(Debug, Clone)]
8pub struct SqlGeneratorSettings {
9    database_type: DatabaseType,
10    database_model: Rc<DatabaseModel>,
11    statement_separator: String,
12    foreign_key_mode: ForeignKeyMode,
13    boolean_mode: BooleanMode,
14    output_mode: OutputMode,
15    target_postgres_version: u32,
16    emit_postgres_extensions: bool,
17    extension_check_user: Option<String>,
18    target_sqlserver_version: u32,
19}
20
21impl SqlGeneratorSettings {
22    pub fn new(database_type: DatabaseType, options: &GenerateOptions) -> Self {
23        Self {
24            database_type,
25            database_model: options.database_model.clone(),
26            statement_separator: database_type.statement_separator().to_string(),
27            foreign_key_mode: options.foreign_key_mode,
28            boolean_mode: options.boolean_mode,
29            output_mode: options.output_mode,
30            target_postgres_version: options.target_postgres_version,
31            emit_postgres_extensions: options.emit_postgres_extensions,
32            extension_check_user: options.extension_check_user.clone(),
33            target_sqlserver_version: options.target_sqlserver_version,
34        }
35    }
36
37    pub fn database_type(&self) -> DatabaseType {
38        self.database_type
39    }
40
41    pub fn database_model(&self) -> &Rc<DatabaseModel> {
42        &self.database_model
43    }
44
45    pub fn statement_separator(&self) -> &String {
46        &self.statement_separator
47    }
48
49    pub fn foreign_key_mode(&self) -> ForeignKeyMode {
50        self.foreign_key_mode
51    }
52
53    pub fn boolean_mode(&self) -> BooleanMode {
54        self.boolean_mode
55    }
56
57    pub fn output_mode(&self) -> OutputMode {
58        self.output_mode
59    }
60
61    pub fn target_postgres_version(&self) -> u32 {
62        self.target_postgres_version
63    }
64
65    pub fn emit_postgres_extensions(&self) -> bool {
66        self.emit_postgres_extensions
67    }
68
69    pub fn extension_check_user(&self) -> Option<&String> {
70        self.extension_check_user.as_ref()
71    }
72
73    pub fn target_sqlserver_version(&self) -> u32 {
74        self.target_sqlserver_version
75    }
76}
77
78#[cfg(test)]
79mod tests {
80    use super::*;
81    use crate::common::print_writer::PrintWriter;
82    use schema_model::builder::SchemaBuilder;
83    use schema_model::model::database_model::DatabaseModel;
84    use schema_model::model::types::{BooleanMode, ForeignKeyMode};
85    use std::cell::RefCell;
86
87    #[test]
88    fn statement_separator_matches_database_type_per_dialect() {
89        // Postgres and SQLite batch statements with ";"; SQL Server uses "go" batches.
90        let schema = SchemaBuilder::new(None::<&str>).build();
91        let model =
92            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
93        let options = GenerateOptions::new(
94            std::rc::Rc::new(model),
95            std::rc::Rc::new(RefCell::new(PrintWriter::new(Box::new(Vec::<u8>::new())))),
96        );
97
98        let postgres_settings = SqlGeneratorSettings::new(DatabaseType::Postgresql, &options);
99        let sqlite_settings = SqlGeneratorSettings::new(DatabaseType::Sqlite, &options);
100        let sqlserver_settings = SqlGeneratorSettings::new(DatabaseType::SqlServer, &options);
101
102        assert_eq!(postgres_settings.statement_separator(), ";");
103        assert_eq!(sqlite_settings.statement_separator(), ";");
104        assert_eq!(sqlserver_settings.statement_separator(), "\ngo");
105        assert_eq!(
106            sqlserver_settings.statement_separator(),
107            DatabaseType::SqlServer.statement_separator()
108        );
109    }
110}