Struct Statement 

pub struct Statement { /* private fields */ }

Uma instrução preparada vinculada ao handle de banco de dados de uma Connection.

Implementations

impl Statement

pub fn handle(&self) -> i32

O handle da instrução no lado do servidor.

pub fn stmt_type(&self) -> i32

O tipo da instrução (stmt_type::*, ex.: SELECT, INSERT).

Examples found in repository

examples/dump.rs (line 33)

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 is_select(&self) -> bool

Verdadeiro para instruções que produzem um cursor de linhas.

pub fn set_scrollable(&mut self, yes: bool)

Pede que o próximo Self::execute abra um cursor rolável, habilitando Self::fetch_scroll e seus atalhos (fetch_prior, fetch_absolute, …). Deve ser chamado antes do execute; o servidor precisa suportar cursores roláveis (FB5+ / protocolo ≥ 17 — ver Connection::supports_fetch_scroll).

pub fn is_scrollable(&self) -> bool

Se este statement foi marcado para abrir um cursor rolável.

pub fn set_fetch_size(&mut self, n: i32)

Define quantas linhas pedir por op_fetch (prefetch). Valores maiores reduzem o número de idas ao servidor em SELECTs grandes, ao custo de mais memória de buffer por lote; valores menores reduzem a latência da primeira linha. O padrão é 200. n é fixado em pelo menos 1.

pub fn fetch_size(&self) -> i32

O tamanho de prefetch atual (ver Self::set_fetch_size).

pub fn columns(&self) -> &[ColumnMeta]

Metadados das colunas de saída (vazio para instruções que não são SELECT).

Examples found in repository

examples/dump.rs (line 34)

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 params(&self) -> &[ColumnMeta]

Metadados dos parâmetros de entrada.

pub fn execute( &mut self, conn: &mut Connection, tx: &Transaction, params: &[Value], ) -> Result<()>

Executa a instrução. Para um SELECT isto abre um cursor; prossiga com Self::fetch / Self::fetch_all. Para DML o servidor responde com um op_response simples.

pub fn fetch(&mut self, conn: &mut Connection) -> Result<Option<Vec<Value>>>

Busca a próxima linha, ou None no fim do cursor. Retorna None para uma instrução que não tem cursor aberto (que não é SELECT, ou já esgotada).

pub fn fetch_all(&mut self, conn: &mut Connection) -> Result<Vec<Vec<Value>>>

Esvazia o cursor para um vetor de linhas.

pub fn rows<'a>(&'a mut self, conn: &'a mut Connection) -> RowStream<'a>

Cria um stream síncrono sobre as linhas do cursor (ver RowStream), empacotando a conexão para não precisar repassá-la a cada linha. As linhas chegam sob demanda (em lotes de Self::fetch_size), sem materializar tudo na memória como Self::fetch_all.

let mut rows = stmt.rows(&mut conn);
while let Some(row) = rows.try_next()? {
    println!("{row:?}");
}

pub fn fetch_scroll( &mut self, conn: &mut Connection, direction: i32, offset: i32, ) -> Result<Option<Vec<Value>>>

Reposiciona o cursor (rolável) e retorna a única linha naquela posição, ou None se ela cai fora do conjunto de resultados. Envia op_fetch_scroll (FB5); o cursor precisa ter sido aberto com Self::set_scrollable.

direction é uma das constantes scroll; offset é a posição absoluta (1-based) para scroll::ABSOLUTE, o deslocamento com sinal para scroll::RELATIVE, e ignorado (use 0) nas demais direções.

pub fn fetch_next( &mut self, conn: &mut Connection, ) -> Result<Option<Vec<Value>>>

Próxima linha (rolável). Equivale a Self::fetch num cursor rolável.

pub fn fetch_prior( &mut self, conn: &mut Connection, ) -> Result<Option<Vec<Value>>>

Linha anterior.

pub fn fetch_first( &mut self, conn: &mut Connection, ) -> Result<Option<Vec<Value>>>

Primeira linha do conjunto de resultados.

pub fn fetch_last( &mut self, conn: &mut Connection, ) -> Result<Option<Vec<Value>>>

Última linha do conjunto de resultados.

pub fn fetch_absolute( &mut self, conn: &mut Connection, pos: i32, ) -> Result<Option<Vec<Value>>>

Linha na posição absoluta pos (1-based; negativa conta a partir do fim).

pub fn fetch_relative( &mut self, conn: &mut Connection, offset: i32, ) -> Result<Option<Vec<Value>>>

Linha offset posições à frente (positivo) ou atrás (negativo) da atual.

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

Quantas linhas a última execução afetou, via op_info_sql com isc_info_sql_records. Útil após um INSERT/UPDATE/DELETE — use RowsAffected::total_modified para o total.

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

Fecha o cursor aberto (op_free_statement com DSQL_close) sem liberar a instrução preparada, para que possa ser reexecutada.

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

Libera a instrução no servidor (op_free_statement com DSQL_drop), consumindo o handle.

Examples found in repository

examples/dump.rs (line 52)

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(())
}

Trait Implementations

impl Debug for Statement

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

Formats the value using the given formatter.

impl Drop for Statement

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.