Struct RowStream 

#[non_exhaustive]
pub struct RowStream<'a> { /* private fields */ }

An async stream of rows from a query result.

Rows are fetched from the server one at a time as the consumer calls next(). This provides natural backpressure and O(1) memory per row.

RowStream borrows the connection mutably. You cannot use the connection while iterating the stream. When the stream is dropped (or fully consumed), the connection is available again.

If the stream is dropped before being fully consumed, the connection is left in an inconsistent state. The Connection::needs_recovery flag is set, and you must call Connection::recover before using the connection again. To avoid this, either consume the stream fully or call RowStream::consume before dropping.

Implementations

impl<'a> RowStream<'a>

pub async fn next(&mut self) -> Result<Option<Row>>

Fetch the next row from the stream.

Returns Ok(Some(row)) when a row is available, Ok(None) when the stream is exhausted, and Err(...) on a server or protocol error. After returning None or Err, subsequent calls return None.

pub fn columns(&self) -> Option<&[FieldDescription]>

Get the column metadata for the current result set.

pub fn command_tag(&self) -> Option<&CommandTag>

Get the command tag after the stream ends.

pub fn is_done(&self) -> bool

Returns true if the stream has been fully consumed or encountered an error.

pub async fn consume(self) -> Result<CommandTag>

Consume the remaining rows in the stream, discarding them.

Trait Implementations

impl<'a> Drop for RowStream<'a>

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.