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