Struct sqlx::QueryAs

pub struct QueryAs<'q, DB, R, P = <DB as Database>::Arguments> where
    DB: Database,  { /* fields omitted */ }

SQL query with bind parameters, which maps rows to an explicit output type.

Returned by [query_as] and query! et al.

The methods on this struct should be passed a reference to crate::Pool or one of the connection types.

Methods

impl<'_, DB, P> QueryAs<'_, DB, (), P> where
    DB: Database,
    P: IntoArguments<DB> + Send, 

The result of query! for SQL queries that does not return output.

pub async fn execute<E>(self, executor: &'_ mut E) -> Result<u64, Error> where
    E: Executor<Database = DB>, 

Execute the query for its side-effects.

Returns the number of rows affected, or 0 if not applicable.

impl<'q, DB, R, P> QueryAs<'q, DB, R, P> where
    DB: Database,
    P: IntoArguments<DB> + Send,
    R: Send + 'q, 

pub fn fetch<'e, E>(
    self,
    executor: &'e mut E
) -> impl Stream<Item = Result<R, Error>> + 'e where
    'q: 'e,
    E: Executor<Database = DB>, 

Execute the query, returning the rows as a futures Stream.

Use [fetch_all] if you want a Vec instead.

pub async fn fetch_all<E>(self, executor: &'_ mut E) -> Result<Vec<R>, Error> where
    E: Executor<Database = DB>, 

Execute the query and get all rows from the result as a Vec.

pub async fn fetch_optional<E>(
    self,
    executor: &'_ mut E
) -> Result<Option<R>, Error> where
    E: Executor<Database = DB>, 

Execute a query which should return either 0 or 1 rows.

Returns crate::Error::FoundMoreThanOne if more than 1 row is returned. Use .fetch().try_next() if you just want one row.

pub async fn fetch_one<E>(self, executor: &'_ mut E) -> Result<R, Error> where
    E: Executor<Database = DB>, 

Execute a query which should return exactly 1 row.

• Returns crate::Error::NotFound if 0 rows are returned.
• Returns crate::Error::FoundMoreThanOne if more than one row is returned.

impl<'q, DB, R> QueryAs<'q, DB, R, <DB as Database>::Arguments> where
    DB: Database,
    <DB as Database>::Arguments: Arguments,
    <<DB as Database>::Arguments as Arguments>::Database == DB, 

pub fn bind<T>(
    self,
    value: T
) -> QueryAs<'q, DB, R, <DB as Database>::Arguments> where
    DB: HasSqlType<T>,
    T: Encode<DB>, 

Bind a value for use with this SQL query.

Logic Safety

This function should be used with care, as SQLx cannot validate that the value is of the right type nor can it validate that you have passed the correct number of parameters.