Struct Row 

pub struct Row { /* private fields */ }

A container for a single row within a query result set.

RowIterator::next() yields a Row.

Each Row contains parsed cell values and a reference to the table schema.

Zero-Copy Struct Mapping via Derive Macros

Define typed structs with #[derive(FromRow)] to convert rows directly into your domain types using TryFrom<Row> without unnecessary allocations:

#[derive(FromRow, Debug)]
struct UserStats {
    name: String,
    count: i64,
}

let user: UserStats = row.try_into()?;
println!("{}: {}", user.name, user.count);

Field Extraction by Name or Index

Retrieve individual cell values by column name (&str) or index (usize) using get() or take():

let name: String = row.get("name")?;
let age: i64 = row.get(1)?;
println!("{name} is {age} years old");

Implementations

impl Row

pub fn get<T: FromSql, I: ColumnIndex>(&self, index: I) -> Result<T, RowError>

Retrieves a value from the row by column name or zero-based index.

The return type must implement FromSql.

The cell value is cloned from the row data without modifying self. If you want to take ownership and avoid cloning large values, see take().

Example

let msg: String = row.get("msg")?;
println!("Value: {msg}");

pub fn take<T: FromSql, I: ColumnIndex>( &mut self, index: I, ) -> Result<T, RowError>

Takes ownership of a value from the row by column name or zero-based index.

This method mutates self by extracting the cell value in-place to avoid cloning. The extracted cell in the row is replaced with NULL. Subsequent attempts to read or take the column will treat it as NULL (returning Ok(None) when reading into Option<T>, or returning a type conversion error for non-nullable types).

take() removes the value from self before converting it to T. If type conversion fails and returns an error, the original value has already been consumed and cannot be recovered from the row.

If you are not sure of the column’s type or need to read the value multiple times, use get() instead of take(). Use take() when you are confident of the type and want to avoid cloning large values (such as strings, byte buffers, or nested records).

Example

let text: String = row.take("big_text")?;
println!("Length: {}", text.len());

// Subsequent reads treat the column as NULL:
assert_eq!(row.get::<Option<String>, _>("big_text")?, None);

// Attempting to read or take again as a non-nullable type fails:
assert!(row.take::<String, _>("big_text").is_err());

Trait Implementations

impl Clone for Row

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Row

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

Formats the value using the given formatter.