Struct postgres::Statement
[−]
[src]
pub struct Statement<'conn> { // some fields omitted }
A prepared statement.
Methods
impl<'conn> Statement<'conn>
[src]
fn param_types(&self) -> &[Type]
Returns a slice containing the expected parameter types.
fn columns(&self) -> &[Column]
Returns a slice describing the columns of the result of the query.
fn execute(&self, params: &[&ToSql]) -> Result<u64>
Executes the prepared statement, returning the number of rows modified.
If the statement does not modify any rows (e.g. SELECT), 0 is returned.
Panics
Panics if the number of parameters provided does not match the number expected.
Example
let stmt = conn.prepare("UPDATE foo SET bar = $1 WHERE baz = $2").unwrap(); match stmt.execute(&[&bar, &baz]) { Ok(count) => println!("{} row(s) updated", count), Err(err) => println!("Error executing query: {:?}", err) }
fn query<'a>(&'a self, params: &[&ToSql]) -> Result<Rows<'a>>
Executes the prepared statement, returning the resulting rows.
Panics
Panics if the number of parameters provided does not match the number expected.
Example
let stmt = conn.prepare("SELECT foo FROM bar WHERE baz = $1").unwrap(); let rows = match stmt.query(&[&baz]) { Ok(rows) => rows, Err(err) => panic!("Error running query: {:?}", err) }; for row in &rows { let foo: i32 = row.get("foo"); println!("foo: {}", foo); }
fn lazy_query<'trans, 'stmt>(&'stmt self, trans: &'trans Transaction, params: &[&ToSql], row_limit: i32) -> Result<LazyRows<'trans, 'stmt>>
Executes the prepared statement, returning a lazily loaded iterator over the resulting rows.
No more than row_limit
rows will be stored in memory at a time. Rows
will be pulled from the database in batches of row_limit
as needed.
If row_limit
is less than or equal to 0, lazy_query
is equivalent
to query
.
This can only be called inside of a transaction, and the Transaction
object representing the active transaction must be passed to
lazy_query
.
Panics
Panics if the provided Transaction
is not associated with the same
Connection
as this Statement
, if the Transaction
is not
active, or if the number of parameters provided does not match the
number of parameters expected.
fn finish(self) -> Result<()>
Consumes the statement, clearing it from the Postgres session.
If this statement was created via the prepare_cached
method, finish
does nothing.
Functionally identical to the Drop
implementation of the
Statement
except that it returns any error to the caller.