Skip to main content

appstruct_schema/
sql.rs

1use crate::{
2    ColumnSchema, DatabaseSchema, DatabaseType, ForeignKeySchema, IndexSchema, SeedSchema,
3    TableSchema, UniqueConstraintSchema,
4};
5use appstruct_ir::{GeneratedValueIr, OnDeleteIr};
6
7#[must_use]
8pub fn initial_migration(schema: &DatabaseSchema) -> String {
9    let mut statements = vec![generated_header()];
10    statements.extend(schema.tables.iter().map(create_table));
11    statements.extend(schema.unique_constraints.iter().map(add_unique_constraint));
12    statements.extend(schema.indexes.iter().map(add_index));
13    statements.extend(schema.seeds.iter().map(add_seed));
14    statements.extend(schema.foreign_keys.iter().map(add_foreign_key));
15    format!("{}\n", statements.join("\n"))
16}
17
18#[must_use]
19pub fn create_table(table: &TableSchema) -> String {
20    let primary_keys = table
21        .columns
22        .iter()
23        .filter(|column| column.primary_key)
24        .collect::<Vec<_>>();
25    let inline_primary_key = primary_keys.len() <= 1;
26    let mut definitions = table
27        .columns
28        .iter()
29        .map(|column| column_definition(column, inline_primary_key))
30        .collect::<Vec<_>>();
31    if !inline_primary_key {
32        let columns = primary_keys
33            .iter()
34            .map(|column| quote_ident(&column.name))
35            .collect::<Vec<_>>()
36            .join(", ");
37        definitions.push(format!("PRIMARY KEY ({columns})"));
38    }
39    let columns = definitions.join(",\n    ");
40    format!(
41        "CREATE TABLE {} (\n    {columns}\n);\n",
42        quote_ident(&table.name)
43    )
44}
45
46#[must_use]
47pub fn column_definition(column: &ColumnSchema, inline_primary_key: bool) -> String {
48    let mut fragments = vec![
49        quote_ident(&column.name),
50        sql_type(&column.data_type).to_owned(),
51    ];
52    if matches!(column.generated, Some(GeneratedValueIr::AutoIncrement)) {
53        fragments.push("GENERATED BY DEFAULT AS IDENTITY".to_owned());
54    }
55    if !column.nullable {
56        fragments.push("NOT NULL".to_owned());
57    }
58    if column.primary_key && inline_primary_key {
59        fragments.push("PRIMARY KEY".to_owned());
60    } else if column.unique {
61        fragments.push("UNIQUE".to_owned());
62    }
63    if let Some(default) = sql_default(column) {
64        fragments.push(format!("DEFAULT {default}"));
65    }
66    if let DatabaseType::Enum { values } = &column.data_type {
67        let choices = values
68            .iter()
69            .map(|value| quote_literal(value))
70            .collect::<Vec<_>>()
71            .join(", ");
72        fragments.push(format!(
73            "CHECK ({} IN ({choices}))",
74            quote_ident(&column.name)
75        ));
76    }
77    fragments.join(" ")
78}
79
80const fn sql_type(data_type: &DatabaseType) -> &'static str {
81    match data_type {
82        DatabaseType::Uuid => "UUID",
83        DatabaseType::Text | DatabaseType::Enum { .. } => "TEXT",
84        DatabaseType::Integer => "INTEGER",
85        DatabaseType::Bigint => "BIGINT",
86        DatabaseType::Decimal => "NUMERIC",
87        DatabaseType::Boolean => "BOOLEAN",
88        DatabaseType::Date => "DATE",
89        DatabaseType::Datetime => "TIMESTAMPTZ",
90        DatabaseType::Json => "JSONB",
91    }
92}
93
94#[must_use]
95pub fn sql_default(column: &ColumnSchema) -> Option<String> {
96    if matches!(column.generated, Some(GeneratedValueIr::Now)) {
97        return Some("CURRENT_TIMESTAMP".to_owned());
98    }
99    if matches!(column.generated, Some(GeneratedValueIr::Revision)) {
100        return Some("1".to_owned());
101    }
102    let value = column.default.as_ref()?;
103    Some(match column.data_type {
104        DatabaseType::Boolean
105        | DatabaseType::Integer
106        | DatabaseType::Bigint
107        | DatabaseType::Decimal => value.clone(),
108        _ => quote_literal(value),
109    })
110}
111
112#[must_use]
113pub fn add_foreign_key(foreign_key: &ForeignKeySchema) -> String {
114    let action = match foreign_key.on_delete {
115        OnDeleteIr::Restrict => "RESTRICT".to_owned(),
116        OnDeleteIr::Cascade => "CASCADE".to_owned(),
117        OnDeleteIr::SetNull if foreign_key.source_columns.len() > 1 => {
118            let nullable_columns = foreign_key.source_columns[1..]
119                .iter()
120                .map(|column| quote_ident(column))
121                .collect::<Vec<_>>()
122                .join(", ");
123            format!("SET NULL ({nullable_columns})")
124        }
125        OnDeleteIr::SetNull => "SET NULL".to_owned(),
126    };
127    let source_columns = quote_columns(&foreign_key.source_columns);
128    let target_columns = quote_columns(&foreign_key.target_columns);
129    let constraint = format!(
130        "fk_{}_{}",
131        foreign_key.source_table,
132        foreign_key.source_columns.join("_")
133    );
134    format!(
135        "ALTER TABLE {} ADD CONSTRAINT {} FOREIGN KEY ({source_columns}) REFERENCES {} ({target_columns}) ON DELETE {action};\n",
136        quote_ident(&foreign_key.source_table),
137        quote_ident(&constraint),
138        quote_ident(&foreign_key.target_table),
139    )
140}
141
142#[must_use]
143pub fn add_unique_constraint(constraint: &UniqueConstraintSchema) -> String {
144    let name = format!("uq_{}_{}", constraint.table, constraint.columns.join("_"));
145    let columns = quote_columns(&constraint.columns);
146    format!(
147        "ALTER TABLE {} ADD CONSTRAINT {} UNIQUE ({columns});\n",
148        quote_ident(&constraint.table),
149        quote_ident(&name)
150    )
151}
152
153#[must_use]
154pub fn add_index(index: &IndexSchema) -> String {
155    let unique = if index.unique { " UNIQUE" } else { "" };
156    let predicate = index
157        .predicate
158        .as_ref()
159        .map_or_else(String::new, |value| format!(" WHERE ({value})"));
160    let extension = if index.operator_class == Some(appstruct_ir::IndexOperatorClass::GinTrgmOps) {
161        "CREATE EXTENSION IF NOT EXISTS pg_trgm;\n"
162    } else {
163        ""
164    };
165    let method = if index.method == appstruct_ir::IndexMethod::Btree {
166        String::new()
167    } else {
168        format!(" USING {}", index.method.sql())
169    };
170    let columns = index
171        .columns
172        .iter()
173        .map(|column| {
174            let class = index
175                .operator_class
176                .map_or_else(String::new, |class| format!(" {}", class.sql()));
177            format!("{}{class}", quote_ident(column))
178        })
179        .collect::<Vec<_>>()
180        .join(", ");
181    format!(
182        "{extension}CREATE{unique} INDEX {} ON {}{method} ({columns}){predicate};\n",
183        quote_ident(&index_name(index)),
184        quote_ident(&index.table),
185    )
186}
187
188fn index_name(index: &IndexSchema) -> String {
189    let suffix = index.id.rsplit("::").next().unwrap_or(index.id.as_str());
190    format!("idx_{}", suffix.replace('.', "_"))
191}
192
193#[must_use]
194pub fn add_seed(seed: &SeedSchema) -> String {
195    let columns = seed
196        .values
197        .iter()
198        .map(|value| quote_ident(&value.column))
199        .collect::<Vec<_>>()
200        .join(", ");
201    let values = seed
202        .values
203        .iter()
204        .map(|value| seed_value(&value.value, &value.data_type))
205        .collect::<Vec<_>>()
206        .join(", ");
207    format!(
208        "INSERT INTO {} ({columns}) VALUES ({values}) ON CONFLICT DO NOTHING;\n",
209        quote_ident(&seed.table)
210    )
211}
212
213fn seed_value(value: &str, data_type: &DatabaseType) -> String {
214    match data_type {
215        DatabaseType::Boolean if matches!(value, "true" | "false") => value.to_owned(),
216        DatabaseType::Integer if value.parse::<i32>().is_ok() => value.to_owned(),
217        DatabaseType::Bigint if value.parse::<i64>().is_ok() => value.to_owned(),
218        DatabaseType::Decimal if value.parse::<f64>().is_ok_and(f64::is_finite) => value.to_owned(),
219        _ => quote_literal(value),
220    }
221}
222
223fn quote_columns(columns: &[String]) -> String {
224    columns
225        .iter()
226        .map(|column| quote_ident(column))
227        .collect::<Vec<_>>()
228        .join(", ")
229}
230
231#[must_use]
232pub fn generated_header() -> String {
233    "-- @generated by AppStruct. Review before applying.\n".to_owned()
234}
235
236#[must_use]
237pub fn quote_ident(value: &str) -> String {
238    format!("\"{}\"", value.replace('"', "\"\""))
239}
240
241#[must_use]
242pub fn quote_literal(value: &str) -> String {
243    format!("'{}'", value.replace('\'', "''"))
244}