Fix schema sync drop unique constraint #2994

Author: tyt2y3

Cargo.toml

@@ -62,7 +62,7 @@ sea-orm-macros = { version = "~2.0.0-rc.37", path = "sea-orm-macros", default-fe
     "async",
     "strum",
 ] }
-sea-query = { version = "=1.0.0-rc.31", default-features = false, features = [
+sea-query = { version = "=1.0.0-rc.32", default-features = false, features = [
     "thread-safe",
     "hashable-value",
     "backend-mysql",

src/schema/builder.rs

@@ -459,9 +459,31 @@ impl EntitySchemaInfo {
                         }
                     }
                     if !has_index {
-                        if let Some(drop_existing) = existing_index.get_index_spec().get_name() {
-                            db.execute(sea_query::Index::drop().name(drop_existing))
+                        if let Some(drop_existing) = existing_index
+                            .get_index_spec()
+                            .get_name()
+                            .map(|s| s.to_owned())
+                        {
+                            if db_backend == DbBackend::Postgres {
+                                // On PostgreSQL, unique indexes created via column-level UNIQUE
+                                // (e.g. ADD COLUMN ... UNIQUE) are backed by a named constraint.
+                                // DROP INDEX fails on constraint-owned indexes; use
+                                // ALTER TABLE ... DROP CONSTRAINT instead.
+                                db.execute(
+                                    TableAlterStatement::new()
+                                        .table(
+                                            self.table
+                                                .get_table_name()
+                                                .expect("Checked above")
+                                                .clone(),
+                                        )
+                                        .drop_constraint(drop_existing),
+                                )
                                 .await?;
+                            } else {
+                                db.execute(sea_query::Index::drop().name(drop_existing))
+                                    .await?;
+                            }
                         }
                     }
                 }

tests/schema_sync_tests.rs

@@ -60,6 +60,39 @@ mod product_v2 {
     impl ActiveModelBehavior for ActiveModel {}
 }
 
+// Scenario 4a: initial version — column has UNIQUE.
+mod order_v1 {
+    use sea_orm::entity::prelude::*;
+
+    #[sea_orm::model]
+    #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+    #[sea_orm(table_name = "sync_order")]
+    pub struct Model {
+        #[sea_orm(primary_key)]
+        pub id: i32,
+        #[sea_orm(unique)]
+        pub ref_no: String,
+    }
+
+    impl ActiveModelBehavior for ActiveModel {}
+}
+
+// Scenario 4b: UNIQUE removed from the column.
+mod order_v2 {
+    use sea_orm::entity::prelude::*;
+
+    #[sea_orm::model]
+    #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+    #[sea_orm(table_name = "sync_order")]
+    pub struct Model {
+        #[sea_orm(primary_key)]
+        pub id: i32,
+        pub ref_no: String,
+    }
+
+    impl ActiveModelBehavior for ActiveModel {}
+}
+
 // Scenario 3a: initial version — column exists without UNIQUE.
 mod user_v1 {
     use sea_orm::entity::prelude::*;
@@ -206,6 +239,44 @@ async fn test_sync_make_existing_column_unique() -> Result<(), DbErr> {
     Ok(())
 }
 
+/// Regression test for <https://github.com/SeaQL/sea-orm/issues/2994>.
+///
+/// A column marked `#[sea_orm(unique)]` is synced, then the unique attribute is
+/// removed. The second sync must drop the PostgreSQL constraint without error.
+#[sea_orm_macros::test]
+#[cfg(feature = "sqlx-postgres")]
+async fn test_sync_drop_unique_constraint() -> Result<(), DbErr> {
+    let ctx = TestContext::new("test_sync_drop_unique_constraint").await;
+    let db = &ctx.db;
+
+    #[cfg(feature = "schema-sync")]
+    {
+        // First sync: creates the table with the unique constraint
+        db.get_schema_builder()
+            .register(order_v1::Entity)
+            .sync(db)
+            .await?;
+
+        assert!(
+            pg_index_exists(db, "sync_order", "sync_order_ref_no_key").await?,
+            "unique constraint should exist after first sync"
+        );
+
+        // Second sync: unique is removed — must not error on PostgreSQL
+        db.get_schema_builder()
+            .register(order_v2::Entity)
+            .sync(db)
+            .await?;
+
+        assert!(
+            !pg_index_exists(db, "sync_order", "sync_order_ref_no_key").await?,
+            "unique constraint should be gone after second sync"
+        );
+    }
+
+    Ok(())
+}
+
 #[cfg(feature = "sqlx-postgres")]
 async fn pg_index_exists(db: &DatabaseConnection, table: &str, index: &str) -> Result<bool, DbErr> {
     db.query_one(