Struct sqlx::query::QueryAs

pub struct QueryAs<'q, DB, O, A>
where
    DB: Database,
{ /* private fields */ }

A single SQL query as a prepared statement, mapping results using FromRow. Returned by query_as().

Implementations

impl<'q, DB, O> QueryAs<'q, DB, O, <DB as HasArguments<'q>>::Arguments>

where DB: Database,

pub fn bind<T>( self, value: T ) -> QueryAs<'q, DB, O, <DB as HasArguments<'q>>::Arguments>

where T: 'q + Send + Encode<'q, DB> + Type<DB>,

Bind a value for use with this SQL query.

See Query::bind.

impl<'q, DB, O, A> QueryAs<'q, DB, O, A>

where DB: Database + HasStatementCache,

pub fn persistent(self, value: bool) -> QueryAs<'q, DB, O, A>

If true, the statement will get prepared once and cached to the connection’s statement cache.

If queried once with the flag set to true, all subsequent queries matching the one with the flag will use the cached statement until the cache is cleared.

If false, the prepared statement will be closed after execution.

Default: true.

impl<'q, DB, O, A> QueryAs<'q, DB, O, A>

where DB: Database, A: 'q + IntoArguments<'q, DB>, O: Send + Unpin + for<'r> FromRow<'r, <DB as Database>::Row>,

pub fn fetch<'e, 'c, E>( self, executor: E ) -> Pin<Box<dyn Stream<Item = Result<O, Error>> + Send + 'e>>

where 'c: 'e, 'q: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, O: 'e, A: 'e,

Execute the query and return the generated results as a stream.

pub fn fetch_many<'e, 'c, E>( self, executor: E ) -> Pin<Box<dyn Stream<Item = Result<Either<<DB as Database>::QueryResult, O>, Error>> + Send + 'e>>

where 'c: 'e, 'q: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, O: 'e, A: 'e,

👎Deprecated: Only the SQLite driver supports multiple statements in one prepared statement and that behavior is deprecated. Use sqlx::raw_sql() instead. See https://github.com/launchbadge/sqlx/issues/3108 for discussion.

Execute multiple queries and return the generated results as a stream from each query, in a stream.

pub async fn fetch_all<'e, 'c, E>(self, executor: E) -> Result<Vec<O>, Error>

where 'c: 'e, 'q: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, O: 'e, A: 'e,

Execute the query and return all the resulting rows collected into a Vec.

Note: beware result set size.

This will attempt to collect the full result set of the query into memory.

To avoid exhausting available memory, ensure the result set has a known upper bound, e.g. using LIMIT.

pub async fn fetch_one<'e, 'c, E>(self, executor: E) -> Result<O, Error>

where 'c: 'e, 'q: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, O: 'e, A: 'e,

Execute the query, returning the first row or Error::RowNotFound otherwise.

Note: for best performance, ensure the query returns at most one row.

Depending on the driver implementation, if your query can return more than one row, it may lead to wasted CPU time and bandwidth on the database server.

Even when the driver implementation takes this into account, ensuring the query returns at most one row can result in a more optimal query plan.

If your query has a WHERE clause filtering a unique column by a single value, you’re good.

Otherwise, you might want to add LIMIT 1 to your query.

pub async fn fetch_optional<'e, 'c, E>( self, executor: E ) -> Result<Option<O>, Error>

where 'c: 'e, 'q: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, O: 'e, A: 'e,

Execute the query, returning the first row or None otherwise.

Note: for best performance, ensure the query returns at most one row.

Depending on the driver implementation, if your query can return more than one row, it may lead to wasted CPU time and bandwidth on the database server.

Even when the driver implementation takes this into account, ensuring the query returns at most one row can result in a more optimal query plan.

If your query has a WHERE clause filtering a unique column by a single value, you’re good.

Otherwise, you might want to add LIMIT 1 to your query.

Trait Implementations

impl<'q, DB, O, A> Execute<'q, DB> for QueryAs<'q, DB, O, A>

where O: Send, A: Send + 'q + IntoArguments<'q, DB>, DB: Database,

fn sql(&self) -> &'q str

Gets the SQL that will be executed.

fn statement(&self) -> Option<&<DB as HasStatement<'q>>::Statement>

Gets the previously cached statement, if available.

fn take_arguments(&mut self) -> Option<<DB as HasArguments<'q>>::Arguments>

Returns the arguments to be bound against the query string.

fn persistent(&self) -> bool

Returns true if the statement should be cached.