Struct Statement

pub struct Statement { /* private fields */ }

named prepared postgres statement without information of which Client it belongs to and lifetime cycle management

this type is used as entry point for other statement types like StatementGuarded and StatementUnnamed. itself is rarely directly used and main direct usage is for statement caching where owner of it is tasked with manual management of it’s association and lifetime

Implementations

impl Statement

pub const fn named<'a>(stmt: &'a str, types: &'a [Type]) -> StatementNamed<'a>

construct a new named statement. must be called with Execute::execute method for making a prepared statement.

pub const fn unnamed<'a>( stmt: &'a str, types: &'a [Type], ) -> StatementUnnamed<'a>

construct a new unnamed statement. unnamed statement can bind to it’s parameter values without being prepared by database.

pub fn bind<P>(&self, params: P) -> StatementQuery<'_, P>

where P: AsParams,

bind self to typed value parameters where they are encoded into a valid sql query in binary format

Examples

// prepare a statement with typed parameters.
let stmt = Statement::named("SELECT * FROM users WHERE id = $1 AND age = $2", &[Type::INT4, Type::INT4])
    .execute(&cli).await?;
// bind statement to typed value parameters and start query
let row_stream = stmt.bind([9527_i32, 18]).query(&cli).await?;

pub fn bind_dyn<'p, 't>( &self, params: &'p [&'t (dyn ToSql + Sync)], ) -> StatementQuery<'_, impl ExactSizeIterator<Item = &'t (dyn ToSql + Sync)> + 'p>

Statement::bind for dynamic typed parameters

Examples

// bind to a dynamic typed slice where items have it's own concrete type.
let bind = statement.bind_dyn(&[&9527i32, &"nobody"]);

pub fn params(&self) -> &[Type]

Returns the expected types of the statement’s parameters.

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

Returns information about the columns returned when the statement is queried.

pub fn into_guarded<C>(self, cli: &C) -> StatementGuarded<'_, C>

where C: Query,

Convert self to a drop guarded statement which would cancel on drop.

Trait Implementations

impl<C> AsRef<Statement> for StatementGuarded<'_, C>

where C: Query,

fn as_ref(&self) -> &Statement

Converts this type into a shared reference of the (usually inferred) input type.

impl Default for Statement

fn default() -> Statement

Returns the “default value” for a type.

impl<'s> Encode for &'s Statement

type Output = &'s [Column]

output type defines how a potential async row streaming type should be constructed. certain state from the encode type may need to be passed for constructing the stream

fn encode<const SYNC_MODE: bool>( self, buf: &mut BytesMut, ) -> Result<Self::Output, Error>

impl<'s, C> Execute<'_, C> for &'s Statement

where C: Query,

type ExecuteOutput = ResultFuture<RowAffected>

outcome of execute. used for single time database response: number of rows affected by execution for example.

type QueryOutput = Ready<Result<GenericRowStream<&'s [Column], Typed>, Error>>

outcome of query. used for repeated database response: database rows for example

fn execute(self, cli: &C) -> Self::ExecuteOutput

define how a statement is executed with single time response

fn query(self, cli: &C) -> Self::QueryOutput

define how a statement is queried with repeated response

impl<'s, C> ExecuteBlocking<'_, C> for &'s Statement

where C: Query,

type ExecuteOutput = Result<u64, Error>

type QueryOutput = Result<GenericRowStream<&'s [Column], Typed>, Error>

fn execute_blocking(self, cli: &C) -> Self::ExecuteOutput

fn query_blocking(self, cli: &C) -> Self::QueryOutput