1use heck::ToSnakeCase;
2use sea_orm::{
3 sea_query::{
4 Alias, ColumnDef, Expr, Index, IntoIden, PgInterval, Table, TableAlterStatement,
5 TableCreateStatement, TableForeignKey,
6 },
7 ColumnType, ConnectionTrait, DbErr, ForeignKeyAction,
8};
9pub use sea_orm_migration::schema::*;
10use sea_orm_migration::{prelude::Iden, sea_query, SchemaManager};
11
12#[derive(Iden)]
13enum GeneralIds {
14 CreatedAt,
15 UpdatedAt,
16}
17
18pub fn alter<T: IntoIden + 'static>(name: T) -> TableAlterStatement {
20 Table::alter().table(name).take()
21}
22
23pub fn table_auto_tz<T>(name: T) -> TableCreateStatement
25where
26 T: IntoIden + 'static,
27{
28 timestamps_tz(Table::create().table(name).if_not_exists().take())
29}
30
31#[must_use]
34pub fn timestamps_tz(t: TableCreateStatement) -> TableCreateStatement {
35 let mut t = t;
36 t.col(timestamp_with_time_zone(GeneralIds::CreatedAt).default(Expr::current_timestamp()))
37 .col(timestamp_with_time_zone(GeneralIds::UpdatedAt).default(Expr::current_timestamp()));
38 t.take()
39}
40
41pub fn timestamptz_null<T>(name: T) -> ColumnDef
43where
44 T: IntoIden,
45{
46 ColumnDef::new(name)
47 .timestamp_with_time_zone()
48 .null()
49 .take()
50}
51
52pub fn timestamptz<T>(name: T) -> ColumnDef
54where
55 T: IntoIden,
56{
57 ColumnDef::new(name)
58 .timestamp_with_time_zone()
59 .not_null()
60 .take()
61}
62
63pub fn enum_type<T>(name: T, enum_name: &str) -> ColumnDef
65where
66 T: IntoIden,
67{
68 ColumnDef::new(name)
69 .enumeration::<Alias, Alias, Vec<Alias>>(Alias::new(enum_name), vec![])
70 .not_null()
71 .take()
72}
73
74pub fn enum_type_null<T>(name: T, enum_name: &str) -> ColumnDef
76where
77 T: IntoIden,
78{
79 ColumnDef::new(name)
80 .enumeration::<Alias, Alias, Vec<Alias>>(Alias::new(enum_name), vec![])
81 .null()
82 .take()
83}
84
85pub fn enum_type_with_default<T>(name: T, enum_name: &str, default_value: &str) -> ColumnDef
94where
95 T: IntoIden,
96{
97 ColumnDef::new(name)
98 .enumeration::<Alias, Alias, Vec<Alias>>(Alias::new(enum_name), vec![])
99 .not_null()
100 .default(Expr::val(default_value))
101 .take()
102}
103
104pub fn enum_type_null_with_default<T>(name: T, enum_name: &str, default_value: &str) -> ColumnDef
113where
114 T: IntoIden,
115{
116 ColumnDef::new(name)
117 .enumeration::<Alias, Alias, Vec<Alias>>(Alias::new(enum_name), vec![])
118 .null()
119 .default(Expr::val(default_value))
120 .take()
121}
122
123async fn check_enum_exists(m: &SchemaManager<'_>, enum_name: &str) -> Result<bool, DbErr> {
125 match m.get_database_backend() {
126 sea_orm::DatabaseBackend::Postgres => {
127 let query = format!(
128 "SELECT EXISTS (
129 SELECT 1 FROM pg_type
130 WHERE typname = '{enum_name}'
131 AND typtype = 'e'
132 )"
133 );
134
135 let result = m
136 .get_connection()
137 .query_one_raw(sea_orm::Statement::from_string(
138 sea_orm::DatabaseBackend::Postgres,
139 query,
140 ))
141 .await?;
142
143 Ok(result.is_some_and(|row| row.try_get::<bool>("", "exists").unwrap_or(false)))
144 }
145 sea_orm::DatabaseBackend::Sqlite => {
146 Ok(false)
149 }
150 sea_orm::DatabaseBackend::MySql => {
151 Ok(false)
153 }
154 _ => {
155 Ok(false)
157 }
158 }
159}
160
161#[derive(Debug)]
162pub enum ColType {
163 PkAuto,
164 PkUuid,
165 CharLen(u32),
166 CharLenWithDefault(u32, char),
167 CharLenNull(u32),
168 CharLenUniq(u32),
169 Char,
170 CharWithDefault(char),
171 CharNull,
172 CharUniq,
173 StringLen(u32),
174 StringLenWithDefault(u32, String),
175 StringLenNull(u32),
176 StringLenUniq(u32),
177 String,
178 StringWithDefault(String),
179 StringNull,
180 StringUniq,
181 Text,
182 TextWithDefault(String),
183 TextNull,
184 TextUniq,
185 Integer,
186 IntegerWithDefault(i32),
187 IntegerNull,
188 IntegerUniq,
189 Unsigned,
190 UnsignedWithDefault(u32),
191 UnsignedNull,
192 UnsignedUniq,
193 SmallUnsigned,
194 SmallUnsignedWithDefault(u16),
195 SmallUnsignedNull,
196 SmallUnsignedUniq,
197 BigUnsigned,
198 BigUnsignedWithDefault(u64),
199 BigUnsignedNull,
200 BigUnsignedUniq,
201 SmallInteger,
202 SmallIntegerWithDefault(i16),
203 SmallIntegerNull,
204 SmallIntegerUniq,
205 BigInteger,
206 BigIntegerWithDefault(i64),
207 BigIntegerNull,
208 BigIntegerUniq,
209 Decimal,
210 DecimalWithDefault(f64),
211 DecimalNull,
212 DecimalUniq,
213 DecimalLen(u32, u32),
214 DecimalLenWithDefault(u32, u32, f64),
215 DecimalLenNull(u32, u32),
216 DecimalLenUniq(u32, u32),
217 Float,
218 FloatWithDefault(f32),
219 FloatNull,
220 FloatUniq,
221 Double,
222 DoubleWithDefault(f64),
223 DoubleNull,
224 DoubleUniq,
225 Boolean,
226 BooleanWithDefault(bool),
227 BooleanNull,
228 Date,
229 DateWithDefault(String),
230 DateNull,
231 DateUniq,
232 DateTime,
233 DateTimeWithDefault(String),
234 DateTimeNull,
235 DateTimeUniq,
236 Time,
237 TimeWithDefault(String),
238 TimeNull,
239 TimeUniq,
240 Interval(Option<PgInterval>, Option<u32>),
241 IntervalNull(Option<PgInterval>, Option<u32>),
242 IntervalUniq(Option<PgInterval>, Option<u32>),
243 Binary,
244 BinaryNull,
245 BinaryUniq,
246 BinaryLen(u32),
247 BinaryLenNull(u32),
248 BinaryLenUniq(u32),
249 VarBinary(u32),
250 VarBinaryNull(u32),
251 VarBinaryUniq(u32),
252 TimestampWithTimeZone,
253 TimestampWithTimeZoneWithDefault(String),
254 TimestampWithTimeZoneNull,
255 Json,
256 JsonNull,
257 JsonUniq,
258 JsonBinary,
259 JsonBinaryNull,
260 JsonBinaryUniq,
261 Blob,
262 BlobNull,
263 BlobUniq,
264 Money,
265 MoneyWithDefault(f64),
266 MoneyNull,
267 MoneyUniq,
268 Uuid,
269 UuidNull,
270 UuidUniq,
271 UuidWithDefault(String),
272 UuidUniqWithDefault(String),
273 VarBitLen(u32),
274 VarBitLenNull(u32),
275 VarBitLenUniq(u32),
276 Array(ColumnType),
277 ArrayNull(ColumnType),
278 ArrayUniq(ColumnType),
279 Enum(String, Vec<String>),
281 EnumNull(String, Vec<String>),
282 EnumWithDefault(String, Vec<String>, String),
283 EnumNullWithDefault(String, Vec<String>, String),
284}
285
286pub enum ArrayColType {
287 String,
288 Int,
289 BigInt,
290 Float,
291 Double,
292 Bool,
293}
294
295impl ColType {
296 #[must_use]
297 #[allow(clippy::needless_pass_by_value)]
298 pub fn array(kind: ArrayColType) -> Self {
299 Self::Array(Self::array_col_type(&kind))
300 }
301
302 #[must_use]
303 #[allow(clippy::needless_pass_by_value)]
304 pub fn array_uniq(kind: ArrayColType) -> Self {
305 Self::ArrayUniq(Self::array_col_type(&kind))
306 }
307
308 #[must_use]
309 #[allow(clippy::needless_pass_by_value)]
310 pub fn array_null(kind: ArrayColType) -> Self {
311 Self::ArrayNull(Self::array_col_type(&kind))
312 }
313
314 fn array_col_type(kind: &ArrayColType) -> ColumnType {
315 match kind {
316 ArrayColType::String => ColumnType::string(None),
317 ArrayColType::Int => ColumnType::Integer,
318 ArrayColType::BigInt => ColumnType::BigInteger,
319 ArrayColType::Float => ColumnType::Float,
320 ArrayColType::Double => ColumnType::Double,
321 ArrayColType::Bool => ColumnType::Boolean,
322 }
323 }
324}
325
326impl ColType {
327 #[allow(clippy::too_many_lines)]
328 fn to_def(&self, name: impl IntoIden) -> ColumnDef {
329 match self {
330 Self::PkAuto => big_pk_auto(name),
333 Self::PkUuid => pk_uuid(name),
334 Self::CharLen(len) => char_len(name, *len),
335 Self::CharLenNull(len) => char_len_null(name, *len),
336 Self::CharLenUniq(len) => char_len_uniq(name, *len),
337 Self::Char => char(name),
338 Self::CharNull => char_null(name),
339 Self::CharUniq => char_uniq(name),
340 Self::StringLen(len) => string_len(name, *len),
341 Self::StringLenNull(len) => string_len_null(name, *len),
342 Self::StringLenUniq(len) => string_len_uniq(name, *len),
343 Self::String => string(name),
344 Self::StringNull => string_null(name),
345 Self::StringUniq => string_uniq(name),
346 Self::Text => text(name),
347 Self::TextNull => text_null(name),
348 Self::TextUniq => text_uniq(name),
349 Self::Integer => integer(name),
350 Self::IntegerNull => integer_null(name),
351 Self::IntegerUniq => integer_uniq(name),
352 Self::Unsigned => unsigned(name),
356 Self::UnsignedNull => unsigned_null(name),
357 Self::UnsignedUniq => unsigned_uniq(name),
358 Self::SmallUnsigned => small_unsigned(name),
362 Self::SmallUnsignedNull => small_unsigned_null(name),
363 Self::SmallUnsignedUniq => small_unsigned_uniq(name),
364 Self::BigUnsigned => big_unsigned(name),
365 Self::BigUnsignedNull => big_unsigned_null(name),
366 Self::BigUnsignedUniq => big_unsigned_uniq(name),
367 Self::SmallInteger => small_integer(name),
368 Self::SmallIntegerNull => small_integer_null(name),
369 Self::SmallIntegerUniq => small_integer_uniq(name),
370 Self::BigInteger => big_integer(name),
371 Self::BigIntegerNull => big_integer_null(name),
372 Self::BigIntegerUniq => big_integer_uniq(name),
373 Self::Decimal => decimal(name),
374 Self::DecimalNull => decimal_null(name),
375 Self::DecimalUniq => decimal_uniq(name),
376 Self::DecimalLen(precision, scale) => decimal_len(name, *precision, *scale),
377 Self::DecimalLenNull(precision, scale) => decimal_len_null(name, *precision, *scale),
378 Self::DecimalLenUniq(precision, scale) => decimal_len_uniq(name, *precision, *scale),
379 Self::Float => float(name),
380 Self::FloatNull => float_null(name),
381 Self::FloatUniq => float_uniq(name),
382 Self::Double => double(name),
383 Self::DoubleNull => double_null(name),
384 Self::DoubleUniq => double_uniq(name),
385 Self::Boolean => boolean(name),
386 Self::BooleanNull => boolean_null(name),
387 Self::Date => date(name),
391 Self::DateNull => date_null(name),
392 Self::DateUniq => date_uniq(name),
393 Self::DateTime => date_time(name),
394 Self::DateTimeNull => date_time_null(name),
395 Self::DateTimeUniq => date_time_uniq(name),
396 Self::Time => time(name),
397 Self::TimeNull => time_null(name),
398 Self::TimeUniq => time_uniq(name),
399 Self::Interval(ival, prec) => interval(name, ival.clone(), *prec),
400 Self::IntervalNull(ival, prec) => interval_null(name, ival.clone(), *prec),
401 Self::IntervalUniq(ival, prec) => interval_uniq(name, ival.clone(), *prec),
402 Self::Binary => binary(name),
403 Self::BinaryNull => binary_null(name),
404 Self::BinaryUniq => binary_uniq(name),
405 Self::BinaryLen(len) => binary_len(name, *len),
406 Self::BinaryLenNull(len) => binary_len_null(name, *len),
407 Self::BinaryLenUniq(len) => binary_len_uniq(name, *len),
408 Self::VarBinary(len) => var_binary(name, *len),
409 Self::VarBinaryNull(len) => var_binary_null(name, *len),
410 Self::VarBinaryUniq(len) => var_binary_uniq(name, *len),
411 Self::TimestampWithTimeZone => timestamptz(name),
412 Self::TimestampWithTimeZoneNull => timestamptz_null(name),
413 Self::Json => json(name),
414 Self::JsonNull => json_null(name),
415 Self::JsonUniq => json_uniq(name),
416 Self::JsonBinary => json_binary(name),
417 Self::JsonBinaryNull => json_binary_null(name),
418 Self::JsonBinaryUniq => json_binary_uniq(name),
419 Self::Blob => blob(name),
420 Self::BlobNull => blob_null(name),
421 Self::BlobUniq => blob_uniq(name),
422 Self::Money => money(name),
423 Self::MoneyNull => money_null(name),
424 Self::MoneyUniq => money_uniq(name),
425 Self::Uuid => uuid(name),
426 Self::UuidNull => uuid_null(name),
427 Self::UuidUniq => uuid_uniq(name),
428 Self::VarBitLen(len) => varbit(name, *len),
429 Self::VarBitLenNull(len) => varbit_null(name, *len),
430 Self::VarBitLenUniq(len) => varbit_uniq(name, *len),
431 Self::Array(kind) => array(name, kind.clone()),
432 Self::ArrayNull(kind) => array_null(name, kind.clone()),
433 Self::ArrayUniq(kind) => array_uniq(name, kind.clone()),
434 Self::Enum(enum_name, _) => enum_type(name, enum_name),
436 Self::EnumNull(enum_name, _) => enum_type_null(name, enum_name),
437 Self::EnumWithDefault(enum_name, _, default_value) => {
438 enum_type_with_default(name, enum_name, default_value)
439 }
440 Self::EnumNullWithDefault(enum_name, _, default_value) => {
441 enum_type_null_with_default(name, enum_name, default_value)
442 }
443 Self::MoneyWithDefault(v) => money(name).default(*v).take(),
445 Self::IntegerWithDefault(v) => integer(name).default(*v).take(),
446 Self::UnsignedWithDefault(v) => unsigned(name).default(*v).take(),
447 Self::SmallUnsignedWithDefault(v) => small_unsigned(name).default(*v).take(),
448 Self::BigUnsignedWithDefault(v) => big_unsigned(name).default(*v).take(),
449 Self::SmallIntegerWithDefault(v) => small_integer(name).default(*v).take(),
450 Self::BigIntegerWithDefault(v) => big_integer(name).default(*v).take(),
451 Self::DecimalWithDefault(v) => decimal(name).default(*v).take(),
452 Self::DecimalLenWithDefault(p, s, v) => decimal_len(name, *p, *s).default(*v).take(),
453 Self::FloatWithDefault(v) => float(name).default(*v).take(),
454 Self::DoubleWithDefault(v) => double(name).default(*v).take(),
455 Self::BooleanWithDefault(v) => boolean(name).default(*v).take(),
456 Self::DateWithDefault(v) => date(name).default(v.clone()).take(),
457 Self::DateTimeWithDefault(v) => date_time(name).default(v.clone()).take(),
458 Self::TimeWithDefault(v) => time(name).default(v.clone()).take(),
459 Self::TimestampWithTimeZoneWithDefault(v) => {
460 timestamptz(name).default(v.clone()).take()
461 }
462 Self::CharWithDefault(v) => char(name).default(*v).take(),
463 Self::CharLenWithDefault(len, v) => char_len(name, *len).default(*v).take(),
464 Self::StringWithDefault(v) => string(name).default(v.clone()).take(),
465 Self::StringLenWithDefault(len, v) => string_len(name, *len).default(v.clone()).take(),
466 Self::TextWithDefault(v) => text(name).default(v.clone()).take(),
467 Self::UuidWithDefault(v) => uuid(name).default(Expr::cust(v.clone())).take(),
468 Self::UuidUniqWithDefault(v) => uuid_uniq(name).default(Expr::cust(v.clone())).take(),
469 }
470 }
471}
472
473pub async fn create_table(
491 m: &SchemaManager<'_>,
492 table: &str,
493 cols: &[(&str, ColType)],
494 refs: &[(&str, &str)], ) -> Result<(), DbErr> {
496 create_table_impl(m, table, cols, refs, false, true).await
497}
498
499pub async fn create_join_table(
513 m: &SchemaManager<'_>,
514 table: &str,
515 cols: &[(&str, ColType)],
516 refs: &[(&str, &str)], ) -> Result<(), DbErr> {
518 create_table_impl(m, table, cols, refs, true, true).await
519}
520
521pub async fn create_table_without_timestamps(
538 m: &SchemaManager<'_>,
539 table: &str,
540 cols: &[(&str, ColType)],
541 refs: &[(&str, &str)], ) -> Result<(), DbErr> {
543 create_table_impl(m, table, cols, refs, false, false).await
544}
545
546pub async fn create_join_table_without_timestamps(
560 m: &SchemaManager<'_>,
561 table: &str,
562 cols: &[(&str, ColType)],
563 refs: &[(&str, &str)], ) -> Result<(), DbErr> {
565 create_table_impl(m, table, cols, refs, true, false).await
566}
567
568async fn create_table_impl(
569 m: &SchemaManager<'_>,
570 table: &str,
571 cols: &[(&str, ColType)],
572 refs: &[(&str, &str)], is_join: bool,
574 add_timestamps: bool, ) -> Result<(), DbErr> {
576 let nz_table = normalize_table(table);
577
578 let mut enum_types = std::collections::HashSet::new();
580 for (_, col_type) in cols {
581 match col_type {
582 ColType::Enum(enum_name, variants)
583 | ColType::EnumNull(enum_name, variants)
584 | ColType::EnumWithDefault(enum_name, variants, _)
585 | ColType::EnumNullWithDefault(enum_name, variants, _)
586 if !enum_types.contains(enum_name) =>
587 {
588 enum_types.insert(enum_name.clone());
589
590 let enum_exists = check_enum_exists(m, enum_name).await?;
592
593 if !enum_exists {
594 #[allow(clippy::match_same_arms)]
598 match m.get_database_backend() {
599 sea_orm::DatabaseBackend::Postgres => {
600 let variant_aliases: Vec<Alias> =
601 variants.iter().map(Alias::new).collect();
602 m.create_type(
603 sea_query::extension::postgres::Type::create()
604 .as_enum(Alias::new(enum_name))
605 .values(variant_aliases)
606 .to_owned(),
607 )
608 .await?;
609 }
610 sea_orm::DatabaseBackend::Sqlite => {
611 }
615 sea_orm::DatabaseBackend::MySql => {
616 }
618 _ => {
619 }
621 }
622 }
623 }
624 _ => {}
625 }
626 }
627
628 let mut stmt = if add_timestamps {
630 table_auto_tz(Alias::new(&nz_table))
631 } else {
632 Table::create()
633 .table(Alias::new(&nz_table))
634 .if_not_exists()
635 .take()
636 };
637
638 if is_join {
639 let mut idx = Index::create();
640 idx.name(format!("idx-{nz_table}-refs-pk"))
641 .table(Alias::new(&nz_table));
642
643 for (from_tbl, ref_name) in refs {
644 let nz_from_table = normalize_table(from_tbl);
645 let nz_ref_name = if ref_name.is_empty() {
648 reference_id(&nz_from_table)
649 } else {
650 (*ref_name).to_string()
651 };
652 idx.col(Alias::new(nz_ref_name));
653 }
654 stmt.primary_key(&mut idx);
655 }
656
657 for (name, atype) in cols {
658 stmt.col(atype.to_def(Alias::new(*name)));
659 }
660
661 for (from_tbl, ref_name) in refs {
665 let (nz_from_table, is_nullable) = from_tbl.strip_suffix('?').map_or_else(
667 || (normalize_table(from_tbl), false),
668 |stripped| (normalize_table(stripped), true),
669 );
670 let nz_ref_name = if ref_name.is_empty() {
671 reference_id(&nz_from_table)
672 } else {
673 (*ref_name).to_string()
674 };
675 if !cols.iter().any(|(col_name, _)| *col_name == nz_ref_name) {
677 let col_type = if is_nullable {
679 ColType::BigIntegerNull
680 } else {
681 ColType::BigInteger
682 };
683 stmt.col(col_type.to_def(Alias::new(&nz_ref_name)));
684 }
685 let mut fk = sea_query::ForeignKey::create();
691 fk.name(format!("fk-{nz_table}-{nz_ref_name}-to-{nz_from_table}"));
692 fk.from(Alias::new(&nz_table), Alias::new(&nz_ref_name));
693 fk.to(Alias::new(nz_from_table), Alias::new("id"));
694 if is_nullable {
695 fk.on_delete(ForeignKeyAction::SetNull);
696 fk.on_update(ForeignKeyAction::NoAction);
697 } else {
698 fk.on_delete(ForeignKeyAction::Cascade);
699 fk.on_update(ForeignKeyAction::Cascade);
700 }
701 stmt.foreign_key(&mut fk);
702 }
703 m.create_table(stmt).await?;
704 Ok(())
705}
706
707fn normalize_table(table: &str) -> String {
709 cruet::to_plural(table).to_snake_case()
710}
711
712fn reference_id(totbl: &str) -> String {
714 format!("{}_id", cruet::to_singular(totbl).to_snake_case())
715}
716
717pub async fn add_column(
726 m: &SchemaManager<'_>,
727 table: &str,
728 name: &str,
729 atype: ColType,
730) -> Result<(), DbErr> {
731 let nz_table = normalize_table(table);
732 m.alter_table(
733 alter(Alias::new(nz_table))
734 .add_column(atype.to_def(Alias::new(name)))
735 .to_owned(),
736 )
737 .await?;
738 Ok(())
739}
740
741pub async fn remove_column(m: &SchemaManager<'_>, table: &str, name: &str) -> Result<(), DbErr> {
750 let nz_table = normalize_table(table);
751 m.alter_table(
752 alter(Alias::new(nz_table))
753 .drop_column(Alias::new(name))
754 .to_owned(),
755 )
756 .await?;
757 Ok(())
758}
759
760pub async fn rename_column(
769 m: &SchemaManager<'_>,
770 table: &str,
771 from: &str,
772 to: &str,
773) -> Result<(), DbErr> {
774 let nz_table = normalize_table(table);
775 m.alter_table(
776 alter(Alias::new(nz_table))
777 .rename_column(Alias::new(from), Alias::new(to))
778 .to_owned(),
779 )
780 .await?;
781 Ok(())
782}
783
784pub async fn add_reference(
793 m: &SchemaManager<'_>,
794 fromtbl: &str,
795 totbl: &str,
796 refname: &str,
797) -> Result<(), DbErr> {
798 let nz_fromtbl = normalize_table(fromtbl);
800 let nz_totbl = normalize_table(totbl);
802 let nz_ref_name = if refname.is_empty() {
804 reference_id(&nz_totbl)
805 } else {
806 refname.to_string()
807 };
808 let bk = m.get_database_backend();
809 let col = ColType::BigInteger.to_def(Alias::new(&nz_ref_name));
811 let fk = TableForeignKey::new()
812 .name(format!("fk-{nz_fromtbl}-{nz_ref_name}-to-{nz_totbl}"))
814 .from_tbl(Alias::new(&nz_fromtbl))
816 .from_col(Alias::new(&nz_ref_name))
817 .to_tbl(Alias::new(nz_totbl))
819 .to_col(Alias::new("id"))
820 .on_delete(ForeignKeyAction::Cascade)
821 .on_update(ForeignKeyAction::Cascade)
822 .to_owned();
823 match bk {
824 sea_orm::DatabaseBackend::MySql | sea_orm::DatabaseBackend::Postgres => {
825 m.alter_table(
827 alter(Alias::new(&nz_fromtbl))
828 .add_column(col.clone())
830 .add_foreign_key(&fk)
832 .to_owned(),
833 )
834 .await?;
835 }
836 sea_orm::DatabaseBackend::Sqlite => {
837 m.alter_table(
839 alter(Alias::new(&nz_fromtbl))
840 .add_column(col.clone())
842 .to_owned(),
843 )
844 .await?;
845 }
859 bk => {
860 return Err(DbErr::BackendNotSupported {
861 db: bk.as_str(),
862 ctx: "add_reference",
863 });
864 }
865 }
866 Ok(())
867}
868
869pub async fn remove_reference(
878 m: &SchemaManager<'_>,
879 fromtbl: &str,
880 totbl: &str,
881 refname: &str,
882) -> Result<(), DbErr> {
883 let nz_fromtbl = normalize_table(fromtbl);
885 let nz_totbl = normalize_table(totbl);
887 let nz_ref_name = if refname.is_empty() {
889 reference_id(&nz_totbl)
890 } else {
891 refname.to_string()
892 };
893 let bk = m.get_database_backend();
894 match bk {
895 sea_orm::DatabaseBackend::MySql | sea_orm::DatabaseBackend::Postgres => {
896 m.alter_table(
898 alter(Alias::new(&nz_fromtbl))
899 .drop_foreign_key(
900 Alias::new(format!("fk-{nz_fromtbl}-{nz_ref_name}-to-{nz_totbl}")),
902 )
903 .to_owned(),
904 )
905 .await?;
906 }
907 sea_orm::DatabaseBackend::Sqlite => {
908 }
912 bk => {
913 return Err(DbErr::BackendNotSupported {
914 db: bk.as_str(),
915 ctx: "remove_reference",
916 });
917 }
918 }
919 Ok(())
920}
921
922pub async fn drop_table(m: &SchemaManager<'_>, table: &str) -> Result<(), DbErr> {
931 let nz_table = normalize_table(table);
932 m.drop_table(Table::drop().table(Alias::new(nz_table)).to_owned())
933 .await
934}
935
936pub async fn add_enum_values(
945 m: &SchemaManager<'_>,
946 enum_name: &str,
947 new_values: Vec<String>,
948) -> Result<(), DbErr> {
949 match m.get_database_backend() {
950 sea_orm::DatabaseBackend::Postgres => {
951 for value in new_values {
952 m.get_connection()
953 .execute_raw(sea_orm::Statement::from_string(
954 sea_orm::DatabaseBackend::Postgres,
955 format!("ALTER TYPE {enum_name} ADD VALUE '{value}'"),
956 ))
957 .await?;
958 }
959 }
960 sea_orm::DatabaseBackend::Sqlite => {
961 tracing::info!(
963 "SQLite: Enum values are handled by CHECK constraints. No action needed."
964 );
965 }
966 sea_orm::DatabaseBackend::MySql => {
967 tracing::info!(
969 "MySQL: Enum values are handled by column definition. No action needed."
970 );
971 }
972 db => {
973 tracing::info!(
974 "{}: Unsure how to handle Enum values, no action to be done.",
975 db.as_str()
976 );
977 }
978 }
979 Ok(())
980}
981
982pub async fn drop_enum_type(m: &SchemaManager<'_>, enum_name: &str) -> Result<(), DbErr> {
991 match m.get_database_backend() {
992 sea_orm::DatabaseBackend::Postgres => {
993 let enum_exists = check_enum_exists(m, enum_name).await?;
995 if !enum_exists {
996 tracing::info!("Enum type '{}' does not exist, skipping drop", enum_name);
997 return Ok(());
998 }
999
1000 let query = format!("DROP TYPE IF EXISTS {enum_name} CASCADE");
1002 m.get_connection()
1003 .execute_raw(sea_orm::Statement::from_string(
1004 sea_orm::DatabaseBackend::Postgres,
1005 query,
1006 ))
1007 .await?;
1008 }
1009 _ => {
1010 tracing::info!("No native enum type to drop for this database backend.");
1012 }
1013 }
1014 Ok(())
1015}
1016
1017#[cfg(test)]
1018mod tests {
1019 use super::*;
1020
1021 #[test]
1022 fn reference_id_is_pure_and_normalization_helpers_compose() {
1023 assert_eq!(reference_id(&normalize_table("user")), "user_id");
1029 assert_eq!(reference_id(&normalize_table("users")), "user_id");
1030 }
1031
1032 #[tokio::test]
1033 async fn create_add_remove_reference_agree_on_fk_naming_for_irregular_plural() {
1034 use crate::tests_cfg::postgres::setup_postgres_container;
1035
1036 let (pg_url, _container) = setup_postgres_container().await;
1048
1049 let mut config = crate::tests_cfg::config::get_database_config();
1050 config.uri = pg_url;
1051 config.min_connections = 1;
1052 config.max_connections = 5;
1053
1054 let db = crate::db::connect(&config)
1055 .await
1056 .expect("Failed to connect to PostgreSQL test database");
1057
1058 let manager = sea_orm_migration::SchemaManager::new(&db);
1059
1060 let expected_ref_col = reference_id(&normalize_table("person"));
1063
1064 create_table(&manager, "people", &[("id", ColType::PkAuto)], &[])
1065 .await
1066 .expect("failed to create people table");
1067
1068 create_table(
1071 &manager,
1072 "movies",
1073 &[("id", ColType::PkAuto)],
1074 &[("person", "")],
1075 )
1076 .await
1077 .expect("failed to create movies table with an inline person reference");
1078
1079 remove_reference(&manager, "movies", "person", "")
1084 .await
1085 .expect("remove_reference should find and drop the FK create_table created");
1086
1087 create_table_without_timestamps(&manager, "reviews", &[("id", ColType::PkAuto)], &[])
1090 .await
1091 .expect("failed to create bare reviews table");
1092
1093 add_reference(&manager, "reviews", "person", "")
1094 .await
1095 .expect("add_reference should succeed");
1096
1097 let rows = db
1098 .query_all_raw(sea_orm::Statement::from_string(
1099 sea_orm::DatabaseBackend::Postgres,
1100 format!(
1101 "SELECT column_name FROM information_schema.columns \
1102 WHERE table_name = 'reviews' AND column_name = '{expected_ref_col}'"
1103 ),
1104 ))
1105 .await
1106 .expect("querying reviews columns should succeed");
1107 assert_eq!(
1108 rows.len(),
1109 1,
1110 "add_reference should have created column `{expected_ref_col}` on `reviews`, \
1111 matching create_table's naming for the same reference"
1112 );
1113 }
1114}