1use crate::model::enum_type::EnumType;
2use crate::model::function::Function;
3use crate::model::other_sql::OtherSql;
4use crate::model::procedure::Procedure;
5use crate::model::table::Table;
6use crate::model::types::{DatabaseType, RelationType};
7use crate::model::view::View;
8use std::collections::HashMap;
9
10#[derive(Debug)]
11pub struct Schema {
12 schema_name: Option<String>,
13 case_sensitive_text: bool,
14 tables: Vec<Table>,
15 views: Vec<View>,
16 functions: Vec<Function>,
17 procedures: Vec<Procedure>,
18 other_sql: Vec<OtherSql>,
19 table_map: HashMap<String, usize>,
21 enum_types: HashMap<String, EnumType>,
22}
23
24impl Default for Schema {
25 fn default() -> Self {
26 Self {
27 schema_name: None,
28 case_sensitive_text: true,
29 tables: Vec::new(),
30 views: Vec::new(),
31 functions: Vec::new(),
32 procedures: Vec::new(),
33 other_sql: Vec::new(),
34 table_map: HashMap::new(),
35 enum_types: HashMap::new(),
36 }
37 }
38}
39
40impl Schema {
41 pub fn new<S: Into<String>>(schema_name: Option<S>) -> Self {
42 Self {
43 schema_name: schema_name.map(|s| s.into()),
44 ..Default::default()
45 }
46 }
47
48 pub fn schema_name(&self) -> Option<&str> {
49 self.schema_name.as_deref()
50 }
51
52 pub fn case_sensitive_text(&self) -> bool {
53 self.case_sensitive_text
54 }
55
56 pub fn set_case_sensitive_text(&mut self, value: bool) {
57 self.case_sensitive_text = value;
58 }
59
60 pub fn tables(&self) -> &[Table] {
61 &self.tables
62 }
63
64 pub fn get_table(&self, name: &str) -> &Table {
65 let idx = self.table_index(name);
66 &self.tables[idx]
67 }
68
69 pub(crate) fn get_table_mut(&mut self, name: &str) -> &mut Table {
70 let idx = self.table_index(name);
71 &mut self.tables[idx]
72 }
73
74 pub fn get_table_mut_checked(&mut self, name: &str) -> Option<&mut Table> {
79 let name_lower = name.to_lowercase();
80 let idx = *self.table_map.get(&name_lower)?;
81 Some(&mut self.tables[idx])
82 }
83
84 fn table_index(&self, name: &str) -> usize {
85 let name_lower = name.to_lowercase();
86 *self.table_map.get(&name_lower)
87 .unwrap_or_else(|| panic!("Unable to locate a table with the name '{}'", name))
88 }
89
90 pub fn get_optional_table(&self, name: &str) -> Option<&Table> {
91 let name_lower = name.to_lowercase();
92 self.table_map.get(&name_lower).map(|&idx| &self.tables[idx])
93 }
94
95 pub fn all_views(&self) -> &[View] {
96 &self.views
97 }
98
99 pub fn views(&self, database_type: DatabaseType) -> Vec<View> {
100 self.views
101 .iter()
102 .filter(|view| view.database_type().is_none() || view.database_type().unwrap() == database_type)
103 .cloned()
104 .collect()
105 }
106
107 pub fn enum_types(&self) -> impl Iterator<Item = &EnumType> {
108 let mut enum_types: Vec<&EnumType> = self.enum_types.values().collect();
109 enum_types.sort_by(|a, b| a.name().cmp(b.name()));
110 enum_types.into_iter()
111 }
112
113 pub fn get_enum_type(&self, type_name: &str) -> &EnumType {
114 self.enum_types
115 .get(&type_name.to_lowercase())
116 .unwrap_or_else(|| panic!("Unable to locate an enum type with the name '{}'", type_name))
117 }
118
119 pub fn functions(&self) -> &[Function] {
120 &self.functions
121 }
122
123 pub fn procedures(&self) -> &[Procedure] {
124 &self.procedures
125 }
126
127 pub fn other_sql(&self) -> &[OtherSql] {
128 &self.other_sql
129 }
130
131 pub fn validate(&self) -> Vec<String> {
132 let mut errors: Vec<String> = Vec::new();
133 for table in &self.tables {
134 if table.columns().is_empty() {
135 errors.push(format!(
136 "ERROR: table {} has no columns; generated `create table` SQL would be invalid",
137 table.name()
138 ));
139 }
140
141 for relation in table.relations() {
142 if relation.relation_type() == RelationType::SetNull {
143 let from_column_name = relation.from_column_name();
144 match table.has_column(from_column_name) {
145 true if table.column(from_column_name).is_required() => {
146 errors.push(format!(
147 "ERROR: {}.{} is required. The {}.{} relation specifies setnull, which is not allowed",
148 table.name(),
149 from_column_name,
150 relation.to_table_name(),
151 relation.to_column_name()
152 ));
153 }
154 true => {}
155 false => {
156 errors.push(format!(
157 "ERROR: {}.{} does not exist. The {}.{} relation refers to it as the source column",
158 table.name(),
159 from_column_name,
160 relation.to_table_name(),
161 relation.to_column_name()
162 ));
163 }
164 }
165 }
166 }
167
168 for column in table.columns() {
169 if let Some(enum_type_name) = column.enum_type()
170 && !self.enum_types.contains_key(&enum_type_name.to_lowercase())
171 {
172 errors.push(format!(
173 "ERROR: {}.{} references enum type '{}' which is not defined in this schema",
174 table.name(),
175 column.name(),
176 enum_type_name
177 ));
178 }
179
180 if column.column_type() == crate::model::column_type::ColumnType::Array
181 && column.element_type().is_none()
182 {
183 errors.push(format!(
184 "ERROR: {}.{} is an array column but has no elementType",
185 table.name(),
186 column.name()
187 ));
188 }
189 }
190 }
191 errors
192 }
193
194 pub(crate) fn add_table(&mut self, table: Table) {
195 let idx = self.tables.len();
196 self.table_map.insert(table.name().to_lowercase(), idx);
197 self.tables.push(table);
198 }
199
200 pub fn sort_tables_by_name(&mut self) {
203 self.tables.sort_by(|a, b| a.name().cmp(b.name()));
204
205 self.table_map.clear();
206 for (idx, table) in self.tables.iter().enumerate() {
207 self.table_map.insert(table.name().to_lowercase(), idx);
208 }
209 }
210
211 pub(crate) fn add_view(&mut self, view: View) {
212 self.views.push(view);
213 }
214
215 pub(crate) fn add_enum_type(&mut self, enum_type: EnumType) {
216 self.enum_types
217 .insert(enum_type.name().to_lowercase(), enum_type);
218 }
219
220 pub(crate) fn add_functions(&mut self, functions: Vec<Function>) {
221 self.functions.extend(functions);
222 }
223
224 pub(crate) fn add_procedures(&mut self, procedures: Vec<Procedure>) {
225 self.procedures.extend(procedures);
226 }
227
228 pub(crate) fn add_other_sql(&mut self, other_sql: OtherSql) {
229 self.other_sql.push(other_sql);
230 }
231}
232
233#[cfg(test)]
234mod tests {
235 use super::*;
236 use crate::model::column::Column;
237 use crate::model::column_type::ColumnType;
238 use crate::model::relation::Relation;
239
240 fn make_schema() -> Schema {
241 Schema::new(Some("schema"))
242 }
243
244 #[test]
245 fn add_and_get_table_and_sort() {
246 let mut schema = make_schema();
247 let table1 = Table::new(
248 Some("schema"),
249 "Table1",
250 Option::<&str>::None,
251 crate::model::types::LockEscalation::Auto,
252 false,
253 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
254 Vec::new(),
255 Vec::new(),
256 Vec::new(),
257 Vec::new(),
258 Vec::new(),
259 Vec::new(),
260 Vec::new(),
261 Vec::new(),
262 );
263 let table2 = Table::new(
264 Some("schema"),
265 "Table2",
266 Option::<&str>::None,
267 crate::model::types::LockEscalation::Auto,
268 false,
269 Vec::new(),
270 Vec::new(),
271 Vec::new(),
272 Vec::new(),
273 Vec::new(),
274 Vec::new(),
275 Vec::new(),
276 Vec::new(),
277 Vec::new(),
278 );
279 schema.add_table(table1);
280 schema.add_table(table2);
281 assert_eq!(schema.get_table("Table2").name(), "Table2"); let names: Vec<_> = schema.tables().iter().map(|t| t.name()).collect();
283 assert_eq!(names, vec!["Table1", "Table2"]);
284 assert_eq!(schema.get_table("Table1").name(), "Table1");
286 }
287
288 #[test]
289 fn get_enum_type_is_case_insensitive() {
290 let mut schema = make_schema();
294 schema.add_enum_type(EnumType::new("GenderType", Vec::new()));
295
296 assert_eq!(schema.get_enum_type("GenderType").name(), "GenderType");
297 assert_eq!(schema.get_enum_type("gendertype").name(), "GenderType");
298 assert_eq!(schema.get_enum_type("GENDERTYPE").name(), "GenderType");
299 }
300
301 #[test]
302 fn views_filtered_by_database_type() {
303 let mut s = make_schema();
304 s.add_view(View::new(Some("s"), "v1", "sql1", Some(DatabaseType::Postgresql)));
305 s.add_view(View::new(Some("s"), "v2", "sql2", Some(DatabaseType::SqlServer)));
306 let pg = s.views(DatabaseType::Postgresql);
307 assert_eq!(pg.len(), 1);
308 assert_eq!(pg[0].name(), "v1");
309 }
310
311 #[test]
312 fn validate_setnull_error_when_required() {
313 let mut s = make_schema();
314 let parent = Table::new(
315 Some("s"),
316 "parent",
317 Option::<&str>::None,
318 crate::model::types::LockEscalation::Auto,
319 false,
320 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
321 Vec::new(),
322 Vec::new(),
323 Vec::new(),
324 Vec::new(),
325 Vec::new(),
326 Vec::new(),
327 Vec::new(),
328 Vec::new(),
329 );
330 s.add_table(parent);
331
332 let child = Table::new(
333 Some("s"),
334 "child",
335 Option::<&str>::None,
336 crate::model::types::LockEscalation::Auto,
337 false,
338 vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
339 Vec::new(),
340 Vec::new(),
341 vec![Relation::new(
342 "parent",
343 "id",
344 "child",
345 "pid",
346 RelationType::SetNull,
347 false,
348 )],
349 Vec::new(),
350 Vec::new(),
351 Vec::new(),
352 Vec::new(),
353 Vec::new(),
354 );
355 s.add_table(child);
356
357 let errors = s.validate();
358 assert_eq!(errors.len(), 1);
359 assert!(errors[0].contains("setnull"));
360 }
361
362 #[test]
363 fn validate_reports_error_instead_of_panicking_when_from_column_is_missing() {
364 let mut s = make_schema();
367 let parent = Table::new(
368 Some("s"),
369 "parent",
370 Option::<&str>::None,
371 crate::model::types::LockEscalation::Auto,
372 false,
373 vec![Column::new(Some("s"), "id", ColumnType::Int, 0, 0, true)],
374 Vec::new(),
375 Vec::new(),
376 Vec::new(),
377 Vec::new(),
378 Vec::new(),
379 Vec::new(),
380 Vec::new(),
381 Vec::new(),
382 );
383 s.add_table(parent);
384
385 let child = Table::new(
386 Some("s"),
387 "child",
388 Option::<&str>::None,
389 crate::model::types::LockEscalation::Auto,
390 false,
391 vec![Column::new(Some("s"), "pid", ColumnType::Int, 0, 0, true)],
392 Vec::new(),
393 Vec::new(),
394 vec![Relation::new(
395 "parent",
396 "id",
397 "child",
398 "does_not_exist",
399 RelationType::SetNull,
400 false,
401 )],
402 Vec::new(),
403 Vec::new(),
404 Vec::new(),
405 Vec::new(),
406 Vec::new(),
407 );
408 s.add_table(child);
409
410 let errors = s.validate();
411 assert_eq!(errors.len(), 1);
412 assert!(errors[0].contains("does_not_exist"));
413 }
414
415 #[test]
416 fn validate_reports_error_for_column_referencing_an_undeclared_enum_type() {
417 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
421 use crate::model::column_type::ColumnType as CT;
422
423 let table = TableBuilder::new(Some("s"), "widget")
424 .add_column(
425 ColumnBuilder::new(Some("s"), "status", CT::Enum)
426 .enum_type(Some("StatusType".to_string()))
427 .build(),
428 )
429 .build();
430 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
431
432 let errors = schema.validate();
433 assert_eq!(errors.len(), 1);
434 assert!(errors[0].contains("StatusType"));
435 }
436
437 #[test]
438 fn validate_reports_error_for_table_with_no_columns() {
439 use crate::builder::{SchemaBuilder, TableBuilder};
442
443 let table = TableBuilder::new(Some("s"), "widget").build();
444 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
445
446 let errors = schema.validate();
447 assert_eq!(errors.len(), 1);
448 assert!(errors[0].contains("widget"));
449 assert!(errors[0].contains("no columns"));
450 }
451
452 #[test]
453 fn validate_reports_error_for_array_column_missing_element_type() {
454 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
455 use crate::model::column_type::ColumnType as CT;
456
457 let table = TableBuilder::new(Some("s"), "widget")
458 .add_column(ColumnBuilder::new(Some("s"), "tags", CT::Array).build())
459 .build();
460 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
461
462 let errors = schema.validate();
463 assert_eq!(errors.len(), 1);
464 assert!(errors[0].contains("tags"));
465 assert!(errors[0].contains("elementType"));
466 }
467
468 #[test]
469 fn validate_accepts_array_column_with_element_type_set() {
470 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
471 use crate::model::column_type::ColumnType as CT;
472
473 let table = TableBuilder::new(Some("s"), "widget")
474 .add_column(
475 ColumnBuilder::new(Some("s"), "tags", CT::Array)
476 .element_type(Some("varchar".to_string()))
477 .build(),
478 )
479 .build();
480 let schema = SchemaBuilder::new(Some("s")).add_table(table).build();
481
482 assert!(schema.validate().is_empty());
483 }
484
485 #[test]
486 fn validate_accepts_column_referencing_a_declared_enum_type_case_insensitively() {
487 use crate::builder::{ColumnBuilder, SchemaBuilder, TableBuilder};
488 use crate::model::column_type::ColumnType as CT;
489 use crate::model::enum_type::EnumType;
490
491 let table = TableBuilder::new(Some("s"), "widget")
492 .add_column(
493 ColumnBuilder::new(Some("s"), "status", CT::Enum)
494 .enum_type(Some("statustype".to_string()))
495 .build(),
496 )
497 .build();
498 let schema = SchemaBuilder::new(Some("s"))
499 .add_table(table)
500 .add_enum_type(EnumType::new("StatusType", Vec::new()))
501 .build();
502
503 assert!(schema.validate().is_empty());
504 }
505
506 }