Struct Transaction 

pub struct Transaction { /* private fields */ }

数据库事务

Implementations

impl Transaction

pub fn new(conn: Arc<dyn DatabaseConnection>) -> Self

pub async fn commit(&mut self) -> Result<(), DbError>

Examples found in repository

examples/postgresql_example.rs (line 214)

async fn demonstrate_transactions() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("PostgreSQL transactions (BEGIN / COMMIT / ROLLBACK):");
    let db = Database::postgresql(PG_HOST, PG_PORT, PG_DB, PG_USER, PG_PASS).await?;

    // Commit
    let mut tx = db.begin_transaction().await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Dave".into(),
            40.into(),
        ],
    )
    .await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Frank".into(),
            35.into(),
        ],
    )
    .await?;
    tx.commit().await?;
    println!("  ✅ Transaction committed (2 users)");

    // Rollback
    let mut tx = db.begin_transaction().await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Eve".into(),
            45.into(),
        ],
    )
    .await?;
    tx.rollback().await?;
    println!("  ✅ Transaction rolled back (Eve not saved)");

    let result = db.query("SELECT COUNT(*) AS count FROM users", &[]).await?;
    println!("  ✅ Final user count: {:?}", result.rows[0].get("count"));

    db.close().await?;
    Ok(())
}

pub async fn rollback(&mut self) -> Result<(), DbError>

Examples found in repository

examples/postgresql_example.rs (line 228)

async fn demonstrate_transactions() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("PostgreSQL transactions (BEGIN / COMMIT / ROLLBACK):");
    let db = Database::postgresql(PG_HOST, PG_PORT, PG_DB, PG_USER, PG_PASS).await?;

    // Commit
    let mut tx = db.begin_transaction().await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Dave".into(),
            40.into(),
        ],
    )
    .await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Frank".into(),
            35.into(),
        ],
    )
    .await?;
    tx.commit().await?;
    println!("  ✅ Transaction committed (2 users)");

    // Rollback
    let mut tx = db.begin_transaction().await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Eve".into(),
            45.into(),
        ],
    )
    .await?;
    tx.rollback().await?;
    println!("  ✅ Transaction rolled back (Eve not saved)");

    let result = db.query("SELECT COUNT(*) AS count FROM users", &[]).await?;
    println!("  ✅ Final user count: {:?}", result.rows[0].get("count"));

    db.close().await?;
    Ok(())
}

pub async fn execute( &self, sql: &str, params: &[SqlValue], ) -> Result<u64, DbError>

Examples found in repository

examples/postgresql_example.rs (lines 196-203)

async fn demonstrate_transactions() -> std::result::Result<(), Box<dyn std::error::Error>> {
    println!("PostgreSQL transactions (BEGIN / COMMIT / ROLLBACK):");
    let db = Database::postgresql(PG_HOST, PG_PORT, PG_DB, PG_USER, PG_PASS).await?;

    // Commit
    let mut tx = db.begin_transaction().await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Dave".into(),
            40.into(),
        ],
    )
    .await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Frank".into(),
            35.into(),
        ],
    )
    .await?;
    tx.commit().await?;
    println!("  ✅ Transaction committed (2 users)");

    // Rollback
    let mut tx = db.begin_transaction().await?;
    tx.execute(
        "INSERT INTO users (id, name, age) VALUES ($1, $2, $3)",
        &[
            SimpleUuid::new_v4().to_string().into(),
            "Eve".into(),
            45.into(),
        ],
    )
    .await?;
    tx.rollback().await?;
    println!("  ✅ Transaction rolled back (Eve not saved)");

    let result = db.query("SELECT COUNT(*) AS count FROM users", &[]).await?;
    println!("  ✅ Final user count: {:?}", result.rows[0].get("count"));

    db.close().await?;
    Ok(())
}

pub async fn execute_query( &self, sql: &str, params: &[SqlValue], ) -> Result<QueryResult, DbError>

Trait Implementations

impl Drop for Transaction

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.