Update sea-orm-sync

Author: tyt2y3

sea-orm-sync/src/database/executor.rs

@@ -7,13 +7,16 @@ use crate::{Schema, SchemaBuilder};
 use std::future::Future;
 use std::pin::Pin;
 
-/// A wrapper that holds either a reference to a [`DatabaseConnection`] or [`DatabaseTransaction`].
+/// A wrapper that holds either a reference to a [`DatabaseConnection`] or [`DatabaseTransaction`],
+/// or an owned [`DatabaseTransaction`].
 #[derive(Debug)]
 pub enum DatabaseExecutor<'c> {
     /// A reference to a database connection
     Connection(&'c DatabaseConnection),
     /// A reference to a database transaction
     Transaction(&'c DatabaseTransaction),
+    /// An owned database transaction (used by migration's `SchemaManager::begin()`)
+    OwnedTransaction(DatabaseTransaction),
 }
 
 impl<'c> From<&'c DatabaseConnection> for DatabaseExecutor<'c> {
@@ -33,34 +36,39 @@ impl ConnectionTrait for DatabaseExecutor<'_> {
         match self {
             DatabaseExecutor::Connection(conn) => conn.get_database_backend(),
             DatabaseExecutor::Transaction(trans) => trans.get_database_backend(),
+            DatabaseExecutor::OwnedTransaction(trans) => trans.get_database_backend(),
         }
     }
 
     fn execute_raw(&self, stmt: Statement) -> Result<ExecResult, DbErr> {
         match self {
             DatabaseExecutor::Connection(conn) => conn.execute_raw(stmt),
             DatabaseExecutor::Transaction(trans) => trans.execute_raw(stmt),
+            DatabaseExecutor::OwnedTransaction(trans) => trans.execute_raw(stmt),
         }
     }
 
     fn execute_unprepared(&self, sql: &str) -> Result<ExecResult, DbErr> {
         match self {
             DatabaseExecutor::Connection(conn) => conn.execute_unprepared(sql),
             DatabaseExecutor::Transaction(trans) => trans.execute_unprepared(sql),
+            DatabaseExecutor::OwnedTransaction(trans) => trans.execute_unprepared(sql),
         }
     }
 
     fn query_one_raw(&self, stmt: Statement) -> Result<Option<QueryResult>, DbErr> {
         match self {
             DatabaseExecutor::Connection(conn) => conn.query_one_raw(stmt),
             DatabaseExecutor::Transaction(trans) => trans.query_one_raw(stmt),
+            DatabaseExecutor::OwnedTransaction(trans) => trans.query_one_raw(stmt),
         }
     }
 
     fn query_all_raw(&self, stmt: Statement) -> Result<Vec<QueryResult>, DbErr> {
         match self {
             DatabaseExecutor::Connection(conn) => conn.query_all_raw(stmt),
             DatabaseExecutor::Transaction(trans) => trans.query_all_raw(stmt),
+            DatabaseExecutor::OwnedTransaction(trans) => trans.query_all_raw(stmt),
         }
     }
 }
@@ -72,6 +80,7 @@ impl TransactionTrait for DatabaseExecutor<'_> {
         match self {
             DatabaseExecutor::Connection(conn) => conn.begin(),
             DatabaseExecutor::Transaction(trans) => trans.begin(),
+            DatabaseExecutor::OwnedTransaction(trans) => trans.begin(),
         }
     }
 
@@ -87,6 +96,9 @@ impl TransactionTrait for DatabaseExecutor<'_> {
             DatabaseExecutor::Transaction(trans) => {
                 trans.begin_with_config(isolation_level, access_mode)
             }
+            DatabaseExecutor::OwnedTransaction(trans) => {
+                trans.begin_with_config(isolation_level, access_mode)
+            }
         }
     }
 
@@ -97,6 +109,7 @@ impl TransactionTrait for DatabaseExecutor<'_> {
         match self {
             DatabaseExecutor::Connection(conn) => conn.begin_with_options(options),
             DatabaseExecutor::Transaction(trans) => trans.begin_with_options(options),
+            DatabaseExecutor::OwnedTransaction(trans) => trans.begin_with_options(options),
         }
     }
 
@@ -108,6 +121,7 @@ impl TransactionTrait for DatabaseExecutor<'_> {
         match self {
             DatabaseExecutor::Connection(conn) => conn.transaction(callback),
             DatabaseExecutor::Transaction(trans) => trans.transaction(callback),
+            DatabaseExecutor::OwnedTransaction(trans) => trans.transaction(callback),
         }
     }
 
@@ -128,6 +142,9 @@ impl TransactionTrait for DatabaseExecutor<'_> {
             DatabaseExecutor::Transaction(trans) => {
                 trans.transaction_with_config(callback, isolation_level, access_mode)
             }
+            DatabaseExecutor::OwnedTransaction(trans) => {
+                trans.transaction_with_config(callback, isolation_level, access_mode)
+            }
         }
     }
 }
@@ -159,7 +176,21 @@ impl<'c> IntoDatabaseExecutor<'c> for &'c DatabaseTransaction {
     }
 }
 
+impl IntoDatabaseExecutor<'static> for DatabaseTransaction {
+    fn into_database_executor(self) -> DatabaseExecutor<'static> {
+        DatabaseExecutor::OwnedTransaction(self)
+    }
+}
+
 impl DatabaseExecutor<'_> {
+    /// Returns `true` if this executor is backed by a transaction (borrowed or owned).
+    pub fn is_transaction(&self) -> bool {
+        matches!(
+            self,
+            DatabaseExecutor::Transaction(_) | DatabaseExecutor::OwnedTransaction(_)
+        )
+    }
+
     /// Creates a [`SchemaBuilder`] for this backend
     pub fn get_schema_builder(&self) -> SchemaBuilder {
         Schema::new(self.get_database_backend()).builder()

sea-orm-sync/src/database/mod.rs

@@ -88,6 +88,8 @@ pub struct ConnectOptions {
     pub(crate) schema_search_path: Option<String>,
     /// Application name (PostgreSQL only)
     pub(crate) application_name: Option<String>,
+    /// Statement timeout (PostgreSQL only)
+    pub(crate) statement_timeout: Option<Duration>,
     pub(crate) test_before_acquire: bool,
     /// Only establish connections to the DB as needed. If set to `true`, the db connection will
     /// be created using SQLx's [connect_lazy](https://docs.rs/sqlx/latest/sqlx/struct.Pool.html#method.connect_lazy)
@@ -212,6 +214,7 @@ impl ConnectOptions {
             sqlcipher_key: None,
             schema_search_path: None,
             application_name: None,
+            statement_timeout: None,
             test_before_acquire: true,
             connect_lazy: false,
             after_connect: None,
@@ -371,6 +374,23 @@ impl ConnectOptions {
         self
     }
 
+    /// Set the statement timeout (PostgreSQL only).
+    ///
+    /// This sets the PostgreSQL `statement_timeout` parameter via the connection options,
+    /// causing the server to abort any statement that exceeds the specified duration.
+    /// The timeout is applied at connection time and does not require an extra roundtrip.
+    ///
+    /// Has no effect on MySQL or SQLite connections.
+    pub fn statement_timeout(&mut self, value: Duration) -> &mut Self {
+        self.statement_timeout = Some(value);
+        self
+    }
+
+    /// Get the statement timeout, if set
+    pub fn get_statement_timeout(&self) -> Option<Duration> {
+        self.statement_timeout
+    }
+
     /// If true, the connection will be pinged upon acquiring from the pool (default true).
     pub fn test_before_acquire(&mut self, value: bool) -> &mut Self {
         self.test_before_acquire = value;

sea-orm-sync/src/database/sea_schema_shim.rs

@@ -42,6 +42,9 @@ impl sea_schema::Connection for crate::DatabaseExecutor<'_> {
             crate::DatabaseExecutor::Transaction(txn) => {
                 <DatabaseTransaction as sea_schema::Connection>::query_all(txn, select)
             }
+            crate::DatabaseExecutor::OwnedTransaction(txn) => {
+                <DatabaseTransaction as sea_schema::Connection>::query_all(txn, select)
+            }
         }
     }
 
@@ -53,6 +56,9 @@ impl sea_schema::Connection for crate::DatabaseExecutor<'_> {
             crate::DatabaseExecutor::Transaction(txn) => {
                 <DatabaseTransaction as sea_schema::Connection>::query_all_raw(txn, sql)
             }
+            crate::DatabaseExecutor::OwnedTransaction(txn) => {
+                <DatabaseTransaction as sea_schema::Connection>::query_all_raw(txn, sql)
+            }
         }
     }
 }

sea-orm-sync/src/database/tracing_spans.rs

@@ -120,6 +120,7 @@ macro_rules! db_span {
         let op = $crate::database::tracing_spans::DbOperation::from_sql(sql);
         ::tracing::info_span!(
             $name,
+            otel.kind = "client",
             db.system = $crate::database::tracing_spans::db_system_name($backend),
             db.operation = %op,
             db.statement = ::tracing::field::Empty,

sea-orm-sync/src/driver/rusqlite.rs

@@ -7,7 +7,7 @@ use tracing::{debug, instrument, warn};
 
 pub use OwnedRow as RusqliteRow;
 use rusqlite::{
-    CachedStatement, Row,
+    CachedStatement, OpenFlags, Row,
     types::{FromSql, FromSqlError, Value},
 };
 pub use rusqlite::{
@@ -199,12 +199,52 @@ impl RusqliteConnector {
         // TODO handle disable_statement_logging
         let after_conn = options.after_connect;
 
-        let conn = RusqliteConnection::open(
-            options
-                .url
-                .trim_start_matches("sqlite://")
-                .trim_start_matches("sqlite:"),
-        )
+        let raw = options
+            .url
+            .trim_start_matches("sqlite://")
+            .trim_start_matches("sqlite:");
+
+        let (path, mode) = match raw.find('?') {
+            Some(q) => {
+                let query = &raw[q + 1..];
+                let mut mode = None;
+                for kv in query.split('&') {
+                    if let Some(val) = kv.strip_prefix("mode=") {
+                        mode = Some(val);
+                    } else if !kv.is_empty() {
+                        return Err(DbErr::Conn(RuntimeErr::Internal(format!(
+                            "unsupported SQLite connection parameter: {kv}"
+                        ))));
+                    }
+                }
+                (&raw[..q], mode)
+            }
+            None => (raw, None),
+        };
+
+        let conn = match mode {
+            None | Some("rwc") => RusqliteConnection::open(path),
+            Some("ro") => RusqliteConnection::open_with_flags(
+                path,
+                OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX,
+            ),
+            Some("rw") => RusqliteConnection::open_with_flags(
+                path,
+                OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_NO_MUTEX,
+            ),
+            Some("memory") => RusqliteConnection::open_with_flags(
+                path,
+                OpenFlags::SQLITE_OPEN_MEMORY
+                    | OpenFlags::SQLITE_OPEN_READ_WRITE
+                    | OpenFlags::SQLITE_OPEN_CREATE
+                    | OpenFlags::SQLITE_OPEN_NO_MUTEX,
+            ),
+            Some(other) => {
+                return Err(DbErr::Conn(RuntimeErr::Internal(format!(
+                    "unknown SQLite mode: {other}"
+                ))));
+            }
+        }
         .map_err(conn_err)?;
 
         let conn = RusqliteSharedConnection {

sea-orm-sync/src/driver/sqlx_postgres.rs

@@ -81,6 +81,10 @@ impl SqlxPostgresConnector {
             sqlx_opts = sqlx_opts.application_name(application_name);
         }
 
+        if let Some(timeout) = options.statement_timeout {
+            sqlx_opts = sqlx_opts.options([("statement_timeout", timeout.as_millis().to_string())]);
+        }
+
         if let Some(f) = &options.pg_opts_fn {
             sqlx_opts = f(sqlx_opts);
         }

sea-orm-sync/src/entity/active_model_ex_.rs

@@ -600,6 +600,8 @@
 //! + [A walk-through of SeaORM 2.0](https://www.sea-ql.org/blog/2025-12-05-sea-orm-2.0/)
 //! + [How we made SeaORM synchronous](https://www.sea-ql.org/blog/2025-12-12-sea-orm-2.0/)
 //! + [SeaORM 2.0 Migration Guide](https://www.sea-ql.org/blog/2026-01-12-sea-orm-2.0/)
+//! + [SeaORM now supports Arrow & Parquet](https://www.sea-ql.org/blog/2026-02-22-sea-orm-arrow/)
+//! + [SeaORM 2.0 with SQL Server Support](https://www.sea-ql.org/blog/2026-02-25-sea-orm-x/)
 //!
 //! If you make extensive use of SeaQuery, we recommend checking out our blog post on SeaQuery 1.0 release:
 //!

sea-orm-sync/src/lib.rs

@@ -4,7 +4,7 @@ use crate::{
 };
 use core::fmt::Debug;
 use core::marker::PhantomData;
-use sea_query::{IntoColumnRef, SelectStatement, SimpleExpr};
+use sea_query::{FunctionCall, IntoColumnRef, SelectStatement, SimpleExpr};
 
 /// Defines a structure to perform select operations
 #[derive(Clone, Debug)]
@@ -210,6 +210,12 @@ impl IntoSimpleExpr for SimpleExpr {
     }
 }
 
+impl IntoSimpleExpr for FunctionCall {
+    fn into_simple_expr(self) -> SimpleExpr {
+        SimpleExpr::FunctionCall(self)
+    }
+}
+
 impl<E> Select<E>
 where
     E: EntityTrait,