Struct Statement 

pub struct Statement<'c> { /* private fields */ }

A prepared statement bound to a specific connection lifetime. Today this is a thin wrapper around the raw SQL; Phase 5’s cursor work will grow it into a real prepared-plan cache.

Implementations

impl<'c> Statement<'c>

pub fn run(&mut self) -> Result<String>

Executes a prepared non-query statement. Equivalent to Connection::execute — included for parity with the typed-row query() so callers who want Statement::run / Statement::query symmetry get it.

pub fn query(&self) -> Result<Rows>

Runs a SELECT and returns a Rows iterator over typed rows. Errors if the prepared statement isn’t a SELECT.

Examples found in repository

examples/rust/quickstart.rs (line 24)

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(())
}

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())
}

pub fn column_names(&self) -> Option<Vec<String>>

Column names this statement will produce, in projection order. None for non-SELECT statements.

Trait Implementations

impl Debug for Statement<'_>

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

Formats the value using the given formatter.