Struct Transaction 

pub struct Transaction { /* private fields */ }

Uma transação iniciada (handle do servidor).

Implementations

impl Transaction

pub fn handle(&self) -> i32

O handle da transação do lado do servidor.

pub fn commit(self, conn: &mut Connection) -> Result<()>

Faz commit e libera a transação.

Examples found in repository

examples/dump.rs (line 53)

fn main() -> Result<()> {
    let cfg = ConnectConfig::new()
        .host(std::env::var("FB_HOST").unwrap_or_else(|_| "127.0.0.1".into()))
        .port(
            std::env::var("FB_PORT")
                .ok()
                .and_then(|p| p.parse().ok())
                .unwrap_or(3555),
        )
        .database(std::env::var("FB_DB").unwrap_or_else(|_| "employee".into()))
        .user(std::env::var("FB_USER").unwrap_or_else(|_| "SYSDBA".into()))
        .password(std::env::var("FB_PASSWORD").expect("set FB_PASSWORD"))
        .wire_crypt(WireCrypt::Enabled);

    let mut conn = Connection::connect(&cfg)?;
    println!("conectado: protocolo v{}", conn.protocol_version());
    let tx = conn.begin()?;

    let sql = "SELECT emp_no, first_name FROM employee WHERE emp_no = 2";
    let stmt = conn.prepare(&tx, sql)?;
    println!(
        "\nstmt_type={} colunas={}",
        stmt.stmt_type(),
        stmt.columns().len()
    );
    for c in stmt.columns() {
        println!(
            "  [{}] name={:?} field={:?} relation={:?} alias={:?} owner={:?} type={} sub={} scale={} len={}",
            c.index,
            c.name(),
            c.field,
            c.relation,
            c.alias,
            c.owner,
            c.sql_type,
            c.sub_type,
            c.scale,
            c.length
        );
    }

    stmt.drop_statement(&mut conn)?;
    tx.commit(&mut conn)?;
    conn.close()?;
    Ok(())
}

pub fn rollback(self, conn: &mut Connection) -> Result<()>

Faz rollback e libera a transação.

pub fn commit_retaining(&self, conn: &mut Connection) -> Result<()>

Faz commit mas mantém o contexto da transação (e o handle) ativo.

pub fn rollback_retaining(&self, conn: &mut Connection) -> Result<()>

Faz rollback mas mantém o contexto da transação (e o handle) ativo.

Trait Implementations

impl Debug for Transaction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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.