schema_sql_generator/sqlserver/
sqlserver_generator.rs1use 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 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 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 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 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}