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 {
33 sql_generator,
34 }
35 }
36
37 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 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 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 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}