Skip to main content

schema_sql_generator/sqlserver/
sqlserver_generator.rs

1use crate::common::generator_context::GeneratorContext;
2use crate::common::sql_generator::{DefaultSqlGenerator, SqlGenerator};
3use crate::common::sql_string::escape_sql_literal;
4use crate::sql_println;
5use crate::sqlserver::sqlserver_function_generator::SqlServerFunctionGenerator;
6use crate::sqlserver::sqlserver_index_generator::SqlServerIndexGenerator;
7use crate::sqlserver::sqlserver_other_sql_generator::SqlServerOtherSqlGenerator;
8use crate::sqlserver::sqlserver_procedure_generator::SqlServerProcedureGenerator;
9use crate::sqlserver::sqlserver_relation_generator::SqlServerRelationGenerator;
10use crate::sqlserver::sqlserver_table_generator::SqlServerTableGenerator;
11use crate::sqlserver::sqlserver_trigger_generator::SqlServerTriggerGenerator;
12use crate::sqlserver::sqlserver_view_generator::SqlServerViewGenerator;
13
14pub struct SqlServerGenerator {
15    sql_generator: DefaultSqlGenerator,
16}
17
18impl SqlServerGenerator {
19    pub fn new(context: GeneratorContext) -> Self {
20        let sql_generator = DefaultSqlGenerator::new(
21            context.clone(),
22            Box::new(SqlServerTableGenerator::new(context.clone())),
23            Box::new(SqlServerRelationGenerator::new(context.clone())),
24            Box::new(SqlServerIndexGenerator::new(context.clone())),
25            Box::new(SqlServerFunctionGenerator::new(context.clone())),
26            Box::new(SqlServerViewGenerator::new(context.clone())),
27            Box::new(SqlServerProcedureGenerator::new(context.clone())),
28            Box::new(SqlServerTriggerGenerator::new(context.clone())),
29            Box::new(SqlServerOtherSqlGenerator::new(context.clone())),
30        );
31
32        Self { sql_generator }
33    }
34
35    /// Emits an existence-guarded `create schema` for every non-default schema the model
36    /// declares (C4). SQL Server requires `CREATE SCHEMA` to be the first statement in its
37    /// batch, so it can't be guarded with a plain `if not exists (...) create schema ...` -
38    /// the dynamic-SQL `exec(...)` form works around that restriction. `dbo` is skipped -
39    /// every SQL Server database always has it.
40    fn create_schemas(&self) {
41        let context = self.context();
42        let separator = context.settings().statement_separator().to_string();
43        let database_model = context.settings().database_model();
44
45        let mut schema_names: Vec<&str> = database_model
46            .schemas()
47            .iter()
48            .filter_map(|schema| schema.schema_name())
49            .filter(|name| !name.eq_ignore_ascii_case("dbo"))
50            .collect();
51        schema_names.sort_unstable();
52        schema_names.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
53
54        if schema_names.is_empty() {
55            return;
56        }
57
58        context.with_writer(|writer| {
59            for schema_name in schema_names {
60                sql_println!(
61                    writer,
62                    "if not exists (select 1 from sys.schemas where name = '{}')",
63                    escape_sql_literal(schema_name)
64                );
65                sql_println!(
66                    writer,
67                    "   exec('create schema {}'){}",
68                    schema_name,
69                    separator
70                );
71            }
72            sql_println!(writer, "");
73        });
74    }
75}
76
77impl SqlGenerator for SqlServerGenerator {
78    fn context(&self) -> &GeneratorContext {
79        self.sql_generator.context()
80    }
81
82    // `generate`/`output_sql` are intentionally *not* overridden here: the trait's default
83    // implementations call `self.output_sql()`/`self.output_header()` on `self`, which for a
84    // `Box<dyn SqlGenerator>` is this type and correctly reaches the `output_header` override
85    // below. Delegating them to `self.sql_generator.generate()`/`.output_sql()` (as this used
86    // to do) would call those methods on the *concrete* `DefaultSqlGenerator` field instead -
87    // the same static-dispatch trap as `SqliteTableGenerator`/`PostgresTableGenerator`
88    // (see H1) - which would silently skip `create_schemas` below.
89
90    fn output_header(&self) {
91        self.create_schemas();
92        self.sql_generator.output_header();
93    }
94
95    fn output_tables(&self) {
96        self.sql_generator.output_tables();
97    }
98
99    fn output_relations(&self) {
100        self.sql_generator.output_relations();
101    }
102
103    fn output_indexes(&self) {
104        self.sql_generator.output_indexes();
105    }
106
107    fn output_triggers(&self) {
108        self.sql_generator.output_triggers();
109    }
110
111    fn output_functions(&self) {
112        self.sql_generator.output_functions();
113    }
114
115    fn output_views(&self) {
116        self.sql_generator.output_views();
117    }
118
119    fn output_procedures(&self) {
120        self.sql_generator.output_procedures();
121    }
122
123    fn output_other_sql_top(&self) {
124        self.sql_generator.output_other_sql_top();
125    }
126
127    fn output_other_sql_bottom(&self) {
128        self.sql_generator.output_other_sql_bottom();
129    }
130}
131
132#[cfg(test)]
133mod tests {
134    use super::*;
135    use crate::common::test_support::make_context;
136    use schema_model::builder::SchemaBuilder;
137    use schema_model::model::database_model::DatabaseModel;
138    use schema_model::model::types::{BooleanMode, DatabaseType, ForeignKeyMode};
139
140    #[test]
141    fn output_header_creates_non_default_schemas() {
142        let default_schema = SchemaBuilder::new(None::<&str>).build();
143        let app_schema = SchemaBuilder::new(Some("app")).build();
144        let model = DatabaseModel::new(
145            BooleanMode::Native,
146            ForeignKeyMode::Relations,
147            vec![default_schema, app_schema],
148        );
149        let (ctx, buffer) = make_context(model, DatabaseType::SqlServer);
150
151        let generator = SqlServerGenerator::new(ctx);
152        generator.output_header();
153
154        let output = buffer.contents();
155        assert!(output.contains("if not exists (select 1 from sys.schemas where name = 'app')"));
156        assert!(output.contains("exec('create schema app')\ngo"));
157    }
158
159    #[test]
160    fn output_header_never_creates_the_dbo_schema() {
161        // `dbo` always exists in SQL Server; guarding and creating it is unnecessary noise.
162        let schema = SchemaBuilder::new(Some("dbo")).build();
163        let model =
164            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
165        let (ctx, buffer) = make_context(model, DatabaseType::SqlServer);
166
167        let generator = SqlServerGenerator::new(ctx);
168        generator.output_header();
169
170        assert!(!buffer.contents().contains("create schema"));
171    }
172
173    #[test]
174    fn output_header_omits_schema_creation_when_only_default_schema_present() {
175        let schema = SchemaBuilder::new(None::<&str>).build();
176        let model =
177            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
178        let (ctx, buffer) = make_context(model, DatabaseType::SqlServer);
179
180        let generator = SqlServerGenerator::new(ctx);
181        generator.output_header();
182
183        assert!(!buffer.contents().contains("create schema"));
184    }
185
186    #[test]
187    fn generate_reaches_create_schemas_via_self_dispatch() {
188        // Regression test: `generate()`/`output_sql()` must resolve `self.output_header()`
189        // back to *this* type's override (not `DefaultSqlGenerator`'s no-op) even when called
190        // through a `Box<dyn SqlGenerator>` - exactly how `GeneratorType::generate` invokes
191        // it. Delegating `generate`/`output_sql` to the inner `sql_generator` field bypassed
192        // this silently.
193        let app_schema = SchemaBuilder::new(Some("app")).build();
194        let model = DatabaseModel::new(
195            BooleanMode::Native,
196            ForeignKeyMode::Relations,
197            vec![app_schema],
198        );
199        let (ctx, buffer) = make_context(model, DatabaseType::SqlServer);
200
201        let generator: Box<dyn SqlGenerator> = Box::new(SqlServerGenerator::new(ctx));
202        generator.generate();
203
204        assert!(buffer.contents().contains("exec('create schema app')"));
205    }
206
207    #[test]
208    fn output_header_escapes_single_quote_in_schema_name() {
209        let schema = SchemaBuilder::new(Some("o'brien")).build();
210        let model =
211            DatabaseModel::new(BooleanMode::Native, ForeignKeyMode::Relations, vec![schema]);
212        let (ctx, buffer) = make_context(model, DatabaseType::SqlServer);
213
214        let generator = SqlServerGenerator::new(ctx);
215        generator.output_header();
216
217        assert!(buffer.contents().contains("where name = 'o''brien'"));
218    }
219}