Trait RowEncoder 

pub trait RowEncoder<F: RecFamily>: Send {
    // Required method
    fn encode<'buf>(
        &mut self,
        rec: &Record<F::Rec<'buf>>,
        buf: &mut BytesMut,
    ) -> Result<(), SinkError>;

    // Provided methods
    fn buffered_bytes(&self) -> usize { ... }
    fn finish_chunk(&mut self, buf: &mut BytesMut) -> Result<(), SinkError> { ... }
}

The CPU half of a sink connector: encodes one record into the sink’s wire format. Runs on pinned pipeline threads inside the chain’s terminal stage; must not perform I/O. Family-generic and dyn-compatible, like Deserializer.

Required Methods

fn encode<'buf>( &mut self, rec: &Record<F::Rec<'buf>>, buf: &mut BytesMut, ) -> Result<(), SinkError>

Append rec’s encoding to buf. Errors are record-level and subject to the sink stage’s ErrorPolicy — except errors of ErrorClass::Fatal, which stop the pipeline regardless of policy (fatal means the encoder itself is broken, e.g. the row type cannot match the target schema; every subsequent record would fail identically).

Provided Methods

fn buffered_bytes(&self) -> usize

Bytes the encoder is holding internally that have not yet been flushed to a frame. Row formats append directly in encode and buffer nothing, so the default is 0. Columnar formats (which must transpose a whole block before any bytes exist) return the approximate size of the block under assembly; the terminal stage adds this to the shard buffer length when deciding whether to seal a chunk, so a columnar block still respects ChunkConfig::target_bytes.

fn finish_chunk(&mut self, buf: &mut BytesMut) -> Result<(), SinkError>

Finalize the pending chunk: flush any internally-buffered rows into buf as exactly one complete, self-describing wire frame, leaving the encoder empty and ready for the next chunk. Row formats already wrote every row in encode, so the default is a no-op. The terminal stage calls this immediately before it seals each EncodedChunk — in steady state, on data lulls, and at drain — so a columnar encoder’s buffered rows are never silently dropped.

An Err is fatal (a broken encoder, not a bad record): the stage ships no partial frame and the buffered rows’ acknowledgements fail on teardown, so the data replays. Because a Native block concatenates with the blocks around it, each finish_chunk frame is independently valid — workers still accumulate frames without re-encoding.

Implementors