bump sea-orm-sync

tyt2y3 · tyt2y3 · commit 903224a75a96 · 2026-04-09T23:37:51.000+01:00
diff --git a/sea-orm-sync/Cargo.toml b/sea-orm-sync/Cargo.toml
@@ -54,15 +54,15 @@ sea-orm-arrow = { version = "2.0.0-rc", path = "../sea-orm-arrow", default-featu
 sea-orm-macros = { version = "~2.0.0-rc.37", path = "../sea-orm-macros", default-features = false, features = [
     "strum",
 ] }
-sea-query = { version = "=1.0.0-rc.32", default-features = false, features = [
+sea-query = { version = "=1.0.0-rc.33", default-features = false, features = [
     "thread-safe",
     "hashable-value",
     "backend-mysql",
     "backend-postgres",
     "backend-sqlite",
     "sea-orm",
 ] }
-sea-query-rusqlite = { version = "0.8.0-rc.14", optional = true }
+sea-query-rusqlite = { version = "0.8.0-rc.15", optional = true }
 sea-schema-sync = { version = "0.17.0-rc.15", default-features = false, features = [
     "sync",
     "discovery",
diff --git a/sea-orm-sync/src/database/mod.rs b/sea-orm-sync/src/database/mod.rs
@@ -1,5 +1,6 @@
 use std::{sync::Arc, time::Duration};
 
+#[cfg(not(feature = "sync"))]
 #[cfg(feature = "sqlx-mysql")]
 use sqlx::mysql::MySqlConnectOptions;
 #[cfg(feature = "sqlx-postgres")]
@@ -53,6 +54,19 @@ pub struct Database;
 #[cfg(feature = "sync")]
 type BoxFuture<'a, T> = T;
 
+#[cfg(feature = "sqlx-mysql")]
+type MapMySqlPoolOptsFn =
+    Arc<dyn Fn(sqlx::pool::PoolOptions<sqlx::MySql>) -> sqlx::pool::PoolOptions<sqlx::MySql>>;
+
+#[cfg(feature = "sqlx-postgres")]
+type MapPgPoolOptsFn =
+    Arc<dyn Fn(sqlx::pool::PoolOptions<sqlx::Postgres>) -> sqlx::pool::PoolOptions<sqlx::Postgres>>;
+
+#[cfg(feature = "sqlx-sqlite")]
+type MapSqlitePoolOptsFn = Option<
+    Arc<dyn Fn(sqlx::pool::PoolOptions<sqlx::Sqlite>) -> sqlx::pool::PoolOptions<sqlx::Sqlite>>,
+>;
+
 type AfterConnectCallback =
     Option<Arc<dyn Fn(DatabaseConnection) -> BoxFuture<'static, Result<(), DbErr>> + 'static>>;
 
@@ -99,6 +113,15 @@ pub struct ConnectOptions {
     #[debug(skip)]
     pub(crate) after_connect: AfterConnectCallback,
 
+    #[cfg(feature = "sqlx-mysql")]
+    #[debug(skip)]
+    pub(crate) mysql_pool_opts_fn: Option<MapMySqlPoolOptsFn>,
+    #[cfg(feature = "sqlx-postgres")]
+    #[debug(skip)]
+    pub(crate) pg_pool_opts_fn: Option<MapPgPoolOptsFn>,
+    #[cfg(feature = "sqlx-sqlite")]
+    #[debug(skip)]
+    pub(crate) sqlite_pool_opts_fn: MapSqlitePoolOptsFn,
     #[cfg(feature = "sqlx-mysql")]
     #[debug(skip)]
     pub(crate) mysql_opts_fn: Option<Arc<dyn Fn(MySqlConnectOptions) -> MySqlConnectOptions>>,
@@ -219,6 +242,12 @@ impl ConnectOptions {
             connect_lazy: false,
             after_connect: None,
             #[cfg(feature = "sqlx-mysql")]
+            mysql_pool_opts_fn: None,
+            #[cfg(feature = "sqlx-postgres")]
+            pg_pool_opts_fn: None,
+            #[cfg(feature = "sqlx-sqlite")]
+            sqlite_pool_opts_fn: None,
+            #[cfg(feature = "sqlx-mysql")]
             mysql_opts_fn: None,
             #[cfg(feature = "sqlx-postgres")]
             pg_opts_fn: None,
@@ -431,6 +460,19 @@ impl ConnectOptions {
         self
     }
 
+    #[cfg(feature = "sqlx-mysql")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "sqlx-mysql")))]
+    /// Apply a function to modify the underlying [`sqlx::pool::PoolOptions<sqlx::MySql>`]
+    /// before creating the connection pool.
+    pub fn map_sqlx_mysql_pool_opts<F>(&mut self, f: F) -> &mut Self
+    where
+        F: Fn(sqlx::pool::PoolOptions<sqlx::MySql>) -> sqlx::pool::PoolOptions<sqlx::MySql>
+            + 'static,
+    {
+        self.mysql_pool_opts_fn = Some(Arc::new(f));
+        self
+    }
+
     #[cfg(feature = "sqlx-postgres")]
     #[cfg_attr(docsrs, doc(cfg(feature = "sqlx-postgres")))]
     /// Apply a function to modify the underlying [`PgConnectOptions`] before
@@ -443,6 +485,19 @@ impl ConnectOptions {
         self
     }
 
+    #[cfg(feature = "sqlx-postgres")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "sqlx-postgres")))]
+    /// Apply a function to modify the underlying [`sqlx::pool::PoolOptions<sqlx::Postgres>`]
+    /// before creating the connection pool.
+    pub fn map_sqlx_postgres_pool_opts<F>(&mut self, f: F) -> &mut Self
+    where
+        F: Fn(sqlx::pool::PoolOptions<sqlx::Postgres>) -> sqlx::pool::PoolOptions<sqlx::Postgres>
+            + 'static,
+    {
+        self.pg_pool_opts_fn = Some(Arc::new(f));
+        self
+    }
+
     #[cfg(feature = "sqlx-sqlite")]
     #[cfg_attr(docsrs, doc(cfg(feature = "sqlx-sqlite")))]
     /// Apply a function to modify the underlying [`SqliteConnectOptions`] before
@@ -454,4 +509,17 @@ impl ConnectOptions {
         self.sqlite_opts_fn = Some(Arc::new(f));
         self
     }
+
+    #[cfg(feature = "sqlx-sqlite")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "sqlx-sqlite")))]
+    /// Apply a function to modify the underlying [`sqlx::pool::PoolOptions<sqlx::Sqlite>`]
+    /// before creating the connection pool.
+    pub fn map_sqlx_sqlite_pool_opts<F>(&mut self, f: F) -> &mut Self
+    where
+        F: Fn(sqlx::pool::PoolOptions<sqlx::Sqlite>) -> sqlx::pool::PoolOptions<sqlx::Sqlite>
+            + 'static,
+    {
+        self.sqlite_pool_opts_fn = Some(Arc::new(f));
+        self
+    }
 }
diff --git a/sea-orm-sync/src/driver/sqlx_mysql.rs b/sea-orm-sync/src/driver/sqlx_mysql.rs
@@ -81,14 +81,17 @@ impl SqlxMySqlConnector {
         if let Some(f) = &options.mysql_opts_fn {
             sqlx_opts = f(sqlx_opts);
         }
-
         let after_connect = options.after_connect.clone();
-
-        let pool = if options.connect_lazy {
-            options.sqlx_pool_options().connect_lazy_with(sqlx_opts)
+        let connect_lazy = options.connect_lazy;
+        let mysql_pool_opts_fn = options.mysql_pool_opts_fn.clone();
+        let mut pool_options = options.sqlx_pool_options();
+        if let Some(f) = &mysql_pool_opts_fn {
+            pool_options = f(pool_options);
+        }
+        let pool = if connect_lazy {
+            pool_options.connect_lazy_with(sqlx_opts)
         } else {
-            options
-                .sqlx_pool_options()
+            pool_options
                 .connect_with(sqlx_opts)
                 .map_err(sqlx_error_to_conn_err)?
         };
diff --git a/sea-orm-sync/src/driver/sqlx_postgres.rs b/sea-orm-sync/src/driver/sqlx_postgres.rs
@@ -110,6 +110,7 @@ impl SqlxPostgresConnector {
 
         let lazy = options.connect_lazy;
         let after_connect = options.after_connect.clone();
+        let pg_pool_opts_fn = options.pg_pool_opts_fn.clone();
         let mut pool_options = options.sqlx_pool_options();
 
         if let Some(sql) = set_search_path_sql {
@@ -118,7 +119,9 @@ impl SqlxPostgresConnector {
                 ({ sqlx::Executor::execute(conn, sql.as_str()).map(|_| ()) })
             });
         }
-
+        if let Some(f) = &pg_pool_opts_fn {
+            pool_options = f(pool_options);
+        }
         let pool = if lazy {
             pool_options.connect_lazy_with(sqlx_opts)
         } else {
diff --git a/sea-orm-sync/src/driver/sqlx_sqlite.rs b/sea-orm-sync/src/driver/sqlx_sqlite.rs
@@ -91,12 +91,18 @@ impl SqlxSqliteConnector {
         }
 
         let after_conn = options.after_connect.clone();
+        let connect_lazy = options.connect_lazy;
+        let sqlite_pool_opts_fn = options.sqlite_pool_opts_fn.clone();
+        let mut pool_options = options.sqlx_pool_options();
 
-        let pool = if options.connect_lazy {
-            options.sqlx_pool_options().connect_lazy_with(sqlx_opts)
+        if let Some(f) = &sqlite_pool_opts_fn {
+            pool_options = f(pool_options);
+        }
+
+        let pool = if connect_lazy {
+            pool_options.connect_lazy_with(sqlx_opts)
         } else {
-            options
-                .sqlx_pool_options()
+            pool_options
                 .connect_with(sqlx_opts)
                 .map_err(sqlx_error_to_conn_err)?
         };
diff --git a/sea-orm-sync/src/entity/active_enum.rs b/sea-orm-sync/src/entity/active_enum.rs
@@ -205,6 +205,9 @@ impl TryGetable for sea_query::Enum {
     fn try_get_by<I: ColIdx>(res: &QueryResult, idx: I) -> Result<Self, TryGetError> {
         let value: String = <String as TryGetable>::try_get_by(res, idx)?;
         Ok(Self {
+            // `DeriveActiveEnum` overwrites `type_name` when constructing values for queries, but we
+            // can't reliably recover the enum type name from `QueryResult`. Keeping it empty may
+            // still cause issues if this value is later reused to build SQL (e.g. missing casts).
             type_name: "".into(),
             value: value.into(),
         })
@@ -219,6 +222,7 @@ impl ActiveEnumValue for sea_query::Enum {
             Ok(values
                 .into_iter()
                 .map(|value| Self {
+                    // See comment in `TryGetable for sea_query::Enum` about empty `type_name`.
                     type_name: "".into(),
                     value: value.into(),
                 })
diff --git a/sea-orm-sync/src/executor/query.rs b/sea-orm-sync/src/executor/query.rs
@@ -17,7 +17,7 @@ use crate::debug_print;
 #[cfg(feature = "sqlx-dep")]
 use crate::driver::*;
 #[cfg(feature = "sqlx-dep")]
-use sqlx::Row;
+use sqlx::{Row, TypeInfo, ValueRef};
 
 /// Defines the result of a query operation on a Model
 #[derive(Debug)]
@@ -81,6 +81,37 @@ impl From<DbErr> for TryGetError {
 // QueryResult //
 
 impl QueryResult {
+    #[doc(hidden)]
+    #[cfg(feature = "sqlx-postgres")]
+    pub fn try_get_from_sqlx_postgres<T, I>(&self, idx: I) -> Option<Result<T, TryGetError>>
+    where
+        T: sqlx::Type<sqlx::Postgres> + for<'r> sqlx::Decode<'r, sqlx::Postgres>,
+        I: ColIdx,
+    {
+        match &self.row {
+            QueryResultRow::SqlxPostgres(row) => {
+                let value = match row.try_get_raw(idx.as_sqlx_postgres_index()) {
+                    Ok(value) => value,
+                    Err(err) => return Some(Err(sqlx_error_to_query_err(err).into())),
+                };
+
+                if !value.is_null() {
+                    let ty = value.type_info();
+                    if !ty.is_null() && !T::compatible(&ty) {
+                        return None;
+                    }
+                }
+
+                Some(
+                    row.try_get::<Option<T>, _>(idx.as_sqlx_postgres_index())
+                        .map_err(|e| sqlx_error_to_query_err(e).into())
+                        .and_then(|opt| opt.ok_or_else(|| err_null_idx_col(idx))),
+                )
+            }
+            _ => None,
+        }
+    }
+
     /// Get a value from the query result with an ColIdx
     pub fn try_get_by<T, I>(&self, index: I) -> Result<T, DbErr>
     where
diff --git a/sea-orm-sync/src/schema/builder.rs b/sea-orm-sync/src/schema/builder.rs
@@ -537,10 +537,29 @@ impl EntitySchemaInfo {
                         }
                     }
                     if !has_index {
-                        if let Some(drop_existing) =
-                            existing_index.get_index_spec().get_name().map(|s| s.to_owned())
+                        if let Some(drop_existing) = existing_index
+                            .get_index_spec()
+                            .get_name()
+                            .map(|s| s.to_owned())
                         {
-                            db.execute(sea_query::Index::drop().name(drop_existing))?;
+                            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),
+                                )?;
+                            } else {
+                                db.execute(sea_query::Index::drop().name(drop_existing))?;
+                            }
                         }
                     }
                 }
diff --git a/sea-orm-sync/tests/active_enum_from_query_result_tests.rs b/sea-orm-sync/tests/active_enum_from_query_result_tests.rs
diff --git a/sea-orm-sync/tests/active_enum_tests.rs b/sea-orm-sync/tests/active_enum_tests.rs
diff --git a/sea-orm-sync/tests/common/features/sea_orm_active_enums.rs b/sea-orm-sync/tests/common/features/sea_orm_active_enums.rs
diff --git a/sea-orm-sync/tests/schema_sync_tests.rs b/sea-orm-sync/tests/schema_sync_tests.rs

Original file line number	Diff line number	Diff line change
`@@ -537,10 +537,29 @@ impl EntitySchemaInfo {`
`537`	`537`	`}`
`538`	`538`	`}`
`539`	`539`	`if !has_index {`
`540`		`- if let Some(drop_existing) =`
`541`		`- existing_index.get_index_spec().get_name().map(\|s\| s.to_owned())`
	`540`	`+ if let Some(drop_existing) = existing_index`
	`541`	`+ .get_index_spec()`
	`542`	`+ .get_name()`
	`543`	`+ .map(\|s\| s.to_owned())`
`542`	`544`	`{`
`543`		`- db.execute(sea_query::Index::drop().name(drop_existing))?;`
	`545`	`+ if db_backend == DbBackend::Postgres {`
	`546`	`+ // On PostgreSQL, unique indexes created via column-level UNIQUE`
	`547`	`+ // (e.g. ADD COLUMN ... UNIQUE) are backed by a named constraint.`
	`548`	`+ // DROP INDEX fails on constraint-owned indexes; use`
	`549`	`+ // ALTER TABLE ... DROP CONSTRAINT instead.`
	`550`	`+ db.execute(`
	`551`	`+ TableAlterStatement::new()`
	`552`	`+ .table(`
	`553`	`+ self.table`
	`554`	`+ .get_table_name()`
	`555`	`+ .expect("Checked above")`
	`556`	`+ .clone(),`
	`557`	`+ )`
	`558`	`+ .drop_constraint(drop_existing),`
	`559`	`+ )?;`
	`560`	`+ } else {`
	`561`	`+ db.execute(sea_query::Index::drop().name(drop_existing))?;`
	`562`	`+ }`
`544`	`563`	`}`
`545`	`564`	`}`
`546`	`565`	`}`