Struct Rows 

pub struct Rows { /* private fields */ }

Iterator of typed Row values produced by a SELECT query.

Today Rows is backed by an eager Vec<Vec<Value>> — the cursor abstraction in Phase 5a’s follow-up will swap this for a lazy walker that streams rows off the B-Tree without materializing them upfront. The Rows::next API is designed for that: it returns Result<Option<Row>> rather than Option<Result<Row>>, so a mid-stream I/O error surfaces cleanly.

Implementations

impl Rows

pub fn columns(&self) -> &[String]

Column names in projection order.

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

Advances to the next row. Returns Ok(None) when the query is exhausted, Ok(Some(row)) otherwise, Err(_) on an I/O or decode failure (relevant once Phase 5a’s cursor work lands — today this is always Ok(_)).

Examples found in repository

examples/rust/quickstart.rs (line 25)

fn main() -> Result<()> {
    let mut conn = Connection::open_in_memory()?;

    conn.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER);")?;
    conn.execute("INSERT INTO users (name, age) VALUES ('alice', 30);")?;
    conn.execute("INSERT INTO users (name, age) VALUES ('bob', 25);")?;
    conn.execute("INSERT INTO users (name, age) VALUES ('charlie', 40);")?;

    println!("All users:");
    let stmt = conn.prepare("SELECT id, name, age FROM users;")?;
    let mut rows = stmt.query()?;
    while let Some(row) = rows.next()? {
        let id: i64 = row.get_by_name("id")?;
        let name: String = row.get_by_name("name")?;
        // `Option<i64>` wraps NULL cleanly — `age` is declared
        // nullable so the typed accessor surfaces None when absent.
        let age: Option<i64> = row.get_by_name("age")?;
        println!(
            "  {} — {} ({})",
            id,
            name,
            age.map(|a| a.to_string())
                .unwrap_or_else(|| "NULL".to_string())
        );
    }

    // Transactions: BEGIN + INSERT + ROLLBACK leaves the table untouched.
    conn.execute("BEGIN;")?;
    conn.execute("INSERT INTO users (name, age) VALUES ('will_vanish', 99);")?;
    println!("\nMid-transaction row count: {}", count_users(&mut conn)?);
    conn.execute("ROLLBACK;")?;
    println!(
        "Post-rollback row count:   {} (unchanged)",
        count_users(&mut conn)?
    );

    Ok(())
}

pub fn collect_all(self) -> Result<Vec<OwnedRow>>

Collects every remaining row into a Vec<Row>. Convenient for small result sets; avoid on large queries — that’s what the streaming Rows::next API is for.

Examples found in repository

examples/rust/quickstart.rs (line 55)

fn count_users(conn: &mut Connection) -> Result<usize> {
    let stmt = conn.prepare("SELECT id FROM users;")?;
    let rows = stmt.query()?.collect_all()?;
    Ok(rows.len())
}

Trait Implementations

impl Debug for Rows

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

Formats the value using the given formatter.