Struct Batch 

pub struct Batch { /* private fields */ }

Um lote de mensagens vinculado a uma instrução preparada no servidor.

Crie-o com Connection::create_batch, acumule linhas com Batch::add e envie com Batch::execute. O batch pode ser reutilizado (adicione mais e execute de novo). Ao terminar, chame Batch::close para liberá-lo.

Implementations

impl Batch

pub fn handle(&self) -> i32

O handle da instrução/batch no servidor.

pub fn pending(&self) -> u32

Quantas mensagens estão acumuladas mas ainda não executadas.

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

Os metadados dos parâmetros de entrada (a forma de cada linha esperada).

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

Registra um BLOB no stream do lote e devolve seu id (quad), que deve ser posto no campo BLOB da linha correspondente como Value::Blob.

Só funciona em batches cuja instrução tem coluna BLOB (a política STREAM é ativada automaticamente em Connection::create_batch nesse caso). Como Self::add, apenas acumula na memória; os blobs vão à rede em Self::execute, antes das mensagens que os referenciam.

let id = batch.add_blob(b"conteudo do blob")?;
batch.add(&[Value::Text("BAT31".into()), Value::Blob(id)])?;

pub fn set_default_bpb(&mut self, bpb: Vec<u8>) -> Result<()>

Define o BPB (blob parameter buffer) padrão dos blobs do batch (op_batch_set_bpb). O uso típico é marcar os blobs como segmentados (isc_bpb_type = isc_bpb_type_segmented): nesse caso Self::add_blob passa a enquadrar cada blob como um segmento. Deve ser chamado antes de Self::add_blob; o BPB vai à rede em Self::execute, antes dos blobs.

Conveniência: Self::set_segmented monta o BPB segmentado para você.

pub fn set_segmented(&mut self, segmented: bool) -> Result<()>

Atalho para Self::set_default_bpb com um BPB que marca os blobs como segmentados (segmentado = true) ou stream (false, o padrão).

pub fn register_blob(&mut self, existing_id: u64) -> Result<u64>

Mapeia um BLOB já existente (criado fora do batch, p.ex. via Connection::write_blob/Connection::create_blob) para um id local do batch e devolve esse id, que deve ir no campo BLOB da linha como Value::Blob. Útil para reaproveitar BLOBs grandes já gravados sem reenviá-los pelo stream (op_batch_regblob).

Como Self::add_blob, só vale em batches com coluna BLOB; o registro é acumulado e enviado em Self::execute, antes das mensagens.

pub fn add(&mut self, values: &[Value]) -> Result<()>

Adiciona uma linha ao lote. Os valores devem corresponder, em número e tipo, aos parâmetros da instrução (ver Self::params). Apenas acumula na memória; nada vai à rede até Self::execute.

pub fn execute( &mut self, conn: &mut Connection, tx: &Transaction, ) -> Result<BatchResult>

Envia as mensagens acumuladas e executa o lote, retornando o estado de conclusão (contagens por linha e erros por linha). Esvazia o buffer pendente; o batch pode então ser reutilizado.

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

Descarta as mensagens acumuladas que ainda não foram executadas (op_batch_cancel). Não afeta linhas já executadas em chamadas anteriores.

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

Libera o batch e a instrução preparada no servidor (op_batch_rls + op_free_statement com DSQL_drop), consumindo o handle.

Trait Implementations

impl Drop for Batch

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.