Struct sqlx::query::QueryAs

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

Raw SQL query with bind parameters, mapped to a concrete type using FromRow. Returned from 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.

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, Global>> 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, Global>> where
    'c: 'e,
    'q: 'e,
    E: 'e + Executor<'c, Database = DB>,
    DB: 'e,
    O: 'e,
    A: 'e, 

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, Global>, 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 generated results, collected into a Vec.

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 and returns exactly one row.

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 and returns at most one row.

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.