Struct PooledConnection 

pub struct PooledConnection { /* private fields */ }

Guard que representa uma conexão retirada do pool.

Use via std::ops::Deref/std::ops::DerefMut para acessar a Connection. Ao cair fora de escopo, a conexão é devolvida ao pool automaticamente. Se a conexão estiver com falha, chame Self::discard para descartá-la sem devolvê-la.

Implementations

impl PooledConnection

pub fn discard(self)

Descarta a conexão em vez de devolvê-la ao pool. Use após um erro irrecuperável na conexão para evitar contaminar o pool.

Methods from Deref<Target = Connection>

pub fn array_desc( &mut self, tx: &Transaction, relation: &str, field: &str, ) -> Result<ArrayDesc>

Monta o ArrayDesc de uma coluna ARRAY consultando o catálogo do sistema (RDB$*), exatamente como o fbclient faz antes de uma fatia. relation/field são os nomes como armazenados (normalmente maiúsculas; um ColumnMeta de saída já os traz assim).

pub fn read_array( &mut self, tx: &Transaction, array_id: u64, desc: &ArrayDesc, ) -> Result<Vec<Value>>

Lê todos os elementos de um array (op_get_slice). array_id é o id que veio na coluna (Value::Array); desc descreve o tipo e as dimensões. Devolve um valor por elemento, na ordem em que o servidor os transmite.

pub fn write_array( &mut self, tx: &Transaction, desc: &ArrayDesc, values: &[Value], ) -> Result<u64>

Cria um novo array com values (op_put_slice) e devolve seu id, para usar como Value::Array num INSERT/UPDATE. O número de valores deve bater com desc.element_count().

pub fn create_batch(&mut self, tx: &Transaction, sql: &str) -> Result<Batch>

Prepara uma instrução e cria um lote (batch) sobre ela com as opções padrão (BatchOptions::default: fail-fast, com contagens por linha). A instrução deve ter parâmetros (?) — cada Batch::add fornece uma linha de valores.

Para continuar após erros por linha e coletá-los todos, use Self::create_batch_with com BatchOptions::new().multierror(true).

pub fn create_batch_with( &mut self, tx: &Transaction, sql: &str, opts: BatchOptions, ) -> Result<Batch>

Como Self::create_batch, mas com BatchOptions explícitas.

pub fn open_blob(&mut self, tx: &Transaction, blob_id: u64) -> Result<Blob>

Abre um BLOB para leitura pelo seu id (obtido de uma coluna Value::Blob).

pub fn create_blob(&mut self, tx: &Transaction) -> Result<BlobWriter>

Cria um BLOB vazio para escrita (op_create_blob2). Escreva dados com BlobWriter::write e finalize com BlobWriter::close para obter o id do blob. Em caso de erro, chame BlobWriter::cancel.

pub fn write_blob(&mut self, tx: &Transaction, data: &[u8]) -> Result<u64>

Conveniência: cria um BLOB, escreve data integralmente e o fecha, devolvendo o id para usar como parâmetro de coluna BLOB.

pub fn read_blob(&mut self, tx: &Transaction, blob_id: u64) -> Result<Vec<u8>>

Conveniência: abre o BLOB, lê todo o conteúdo e o fecha, devolvendo os bytes. Fecha mesmo se a leitura falhar.

pub fn charset(&self) -> Charset

O charset da conexão, usado para decodificar texto vindo do servidor.

pub fn ping(&mut self) -> Result<()>

Faz um round-trip de op_ping para verificar se a conexão está viva.

pub fn protocol_version(&self) -> i32

A versão de protocolo negociada (número base, ex.: 18 para FB5).

pub fn supports_batch(&self) -> bool

Se o protocolo negociado suporta as ops de batch (array-DML).

pub fn supports_fetch_scroll(&self) -> bool

Se o protocolo negociado suporta cursores roláveis (scrollable).

pub fn exec_immediate( &mut self, tx: Option<&Transaction>, sql: &str, ) -> Result<()>

Executa um comando SQL sem prepare prévio (op_exec_immediate). Use para DDL (CREATE/ALTER/DROP TABLE, índices, procedures…) ou DML sem retorno de linhas.

Passe None para deixar o driver criar e fazer commit de uma transação implícita (necessário para DDL autocommit). Passe Some(&tx) para executar dentro de uma transação existente.

pub fn is_encrypted(&self) -> bool

Se a comunicação (wire) está criptografada.

pub fn is_healthy(&self) -> bool

Se a conexão ainda está sã (sem erro de I/O nem desync de protocolo). O crate::Pool usa isto para descartar conexões com falha em vez de devolvê-las ao conjunto de ociosas.

pub fn listen_events(&mut self, names: &[&str]) -> Result<EventListener>

Registra interesse nos eventos nomeados e abre o canal auxiliar por onde o servidor empurra as notificações. Use EventListener::wait para aguardar.

let mut ev = conn.listen_events(&["minha_tabela_mudou"])?;
let disparados = ev.wait(&mut conn)?;   // bloqueia até um POST
ev.cancel(&mut conn)?;

pub fn prepare(&mut self, tx: &Transaction, sql: &str) -> Result<Statement>

Prepara uma instrução SQL dentro da transação informada.

pub fn begin(&mut self) -> Result<Transaction>

Inicia uma transação com parâmetros padrão (snapshot, leitura e escrita, wait).

pub fn begin_with( &mut self, builder: &TransactionBuilder, ) -> Result<Transaction>

Inicia uma transação com parâmetros explícitos.

Trait Implementations

impl Deref for PooledConnection

type Target = Connection

The resulting type after dereferencing.

fn deref(&self) -> &Connection

Dereferences the value.

impl DerefMut for PooledConnection

fn deref_mut(&mut self) -> &mut Connection

Mutably dereferences the value.

impl Drop for PooledConnection

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.