Trait mysql_async::prelude::Queryable

pub trait Queryable: Send {
    // Required methods
    fn ping(&mut self) -> BoxFuture<'_, Result<()>>;
    fn query_iter<'a, Q>(
        &'a mut self,
        query: Q,
    ) -> BoxFuture<'a, Result<QueryResult<'a, 'static, TextProtocol>>>
       where Q: AsQuery + 'a;
    fn prep<'a, Q>(&'a mut self, query: Q) -> BoxFuture<'a, Result<Statement>>
       where Q: AsQuery + 'a;
    fn close(&mut self, stmt: Statement) -> BoxFuture<'_, Result<()>>;
    fn exec_iter<'a: 's, 's, Q, P>(
        &'a mut self,
        stmt: Q,
        params: P,
    ) -> BoxFuture<'s, Result<QueryResult<'a, 'static, BinaryProtocol>>>
       where Q: StatementLike + 'a,
             P: Into<Params>;
    fn exec_batch<'a: 'b, 'b, S, P, I>(
        &'a mut self,
        stmt: S,
        params_iter: I,
    ) -> BoxFuture<'b, Result<()>>
       where S: StatementLike + 'b,
             I: IntoIterator<Item = P> + Send + 'b,
             I::IntoIter: Send,
             P: Into<Params> + Send;

    // Provided methods
    fn query<'a, T, Q>(&'a mut self, query: Q) -> BoxFuture<'a, Result<Vec<T>>>
       where Q: AsQuery + 'a,
             T: FromRow + Send + 'static { ... }
    fn query_first<'a, T, Q>(
        &'a mut self,
        query: Q,
    ) -> BoxFuture<'a, Result<Option<T>>>
       where Q: AsQuery + 'a,
             T: FromRow + Send + 'static { ... }
    fn query_map<'a, T, F, Q, U>(
        &'a mut self,
        query: Q,
        f: F,
    ) -> BoxFuture<'a, Result<Vec<U>>>
       where Q: AsQuery + 'a,
             T: FromRow + Send + 'static,
             F: FnMut(T) -> U + Send + 'a,
             U: Send { ... }
    fn query_fold<'a, T, F, Q, U>(
        &'a mut self,
        query: Q,
        init: U,
        f: F,
    ) -> BoxFuture<'a, Result<U>>
       where Q: AsQuery + 'a,
             T: FromRow + Send + 'static,
             F: FnMut(U, T) -> U + Send + 'a,
             U: Send + 'a { ... }
    fn query_drop<'a, Q>(&'a mut self, query: Q) -> BoxFuture<'a, Result<()>>
       where Q: AsQuery + 'a { ... }
    fn exec<'a: 'b, 'b, T, S, P>(
        &'a mut self,
        stmt: S,
        params: P,
    ) -> BoxFuture<'b, Result<Vec<T>>>
       where S: StatementLike + 'b,
             P: Into<Params> + Send + 'b,
             T: FromRow + Send + 'static { ... }
    fn exec_first<'a: 'b, 'b, T, S, P>(
        &'a mut self,
        stmt: S,
        params: P,
    ) -> BoxFuture<'b, Result<Option<T>>>
       where S: StatementLike + 'b,
             P: Into<Params> + Send + 'b,
             T: FromRow + Send + 'static { ... }
    fn exec_map<'a: 'b, 'b, T, S, P, U, F>(
        &'a mut self,
        stmt: S,
        params: P,
        f: F,
    ) -> BoxFuture<'b, Result<Vec<U>>>
       where S: StatementLike + 'b,
             P: Into<Params> + Send + 'b,
             T: FromRow + Send + 'static,
             F: FnMut(T) -> U + Send + 'a,
             U: Send + 'a { ... }
    fn exec_fold<'a: 'b, 'b, T, S, P, U, F>(
        &'a mut self,
        stmt: S,
        params: P,
        init: U,
        f: F,
    ) -> BoxFuture<'b, Result<U>>
       where S: StatementLike + 'b,
             P: Into<Params> + Send + 'b,
             T: FromRow + Send + 'static,
             F: FnMut(U, T) -> U + Send + 'a,
             U: Send + 'a { ... }
    fn exec_drop<'a: 'b, 'b, S, P>(
        &'a mut self,
        stmt: S,
        params: P,
    ) -> BoxFuture<'b, Result<()>>
       where S: StatementLike + 'b,
             P: Into<Params> + Send + 'b { ... }
    fn query_stream<'a, T, Q>(
        &'a mut self,
        query: Q,
    ) -> BoxFuture<'a, Result<ResultSetStream<'a, 'a, 'static, T, TextProtocol>>>
       where T: Unpin + FromRow + Send + 'static,
             Q: AsQuery + 'a { ... }
    fn exec_stream<'a: 's, 's, T, Q, P>(
        &'a mut self,
        stmt: Q,
        params: P,
    ) -> BoxFuture<'s, Result<ResultSetStream<'a, 'a, 'static, T, BinaryProtocol>>>
       where T: Unpin + FromRow + Send + 'static,
             Q: StatementLike + 'a,
             P: Into<Params> + Send + 's { ... }
}

Methods of this trait are used to execute database queries.

Conn is a Queryable as well as Transaction.

Required Methods

fn ping(&mut self) -> BoxFuture<'_, Result<()>>

Executes COM_PING.

fn query_iter<'a, Q>( &'a mut self, query: Q, ) -> BoxFuture<'a, Result<QueryResult<'a, 'static, TextProtocol>>>

where Q: AsQuery + 'a,

Performs the given query and returns the result.

fn prep<'a, Q>(&'a mut self, query: Q) -> BoxFuture<'a, Result<Statement>>

where Q: AsQuery + 'a,

Prepares the given statement.

Note, that Statement will exist only in the context of this queryable.

Also note, that this call may close the least recently used statement if statement cache is at its capacity (see. stmt_cache_size).

fn close(&mut self, stmt: Statement) -> BoxFuture<'_, Result<()>>

Closes the given statement.

Usually there is no need to explicitly close statements (see. stmt_cache_size).

fn exec_iter<'a: 's, 's, Q, P>( &'a mut self, stmt: Q, params: P, ) -> BoxFuture<'s, Result<QueryResult<'a, 'static, BinaryProtocol>>>

where Q: StatementLike + 'a, P: Into<Params>,

Executes the given statement with given params.

It’ll prepare stmt, if necessary.

fn exec_batch<'a: 'b, 'b, S, P, I>( &'a mut self, stmt: S, params_iter: I, ) -> BoxFuture<'b, Result<()>>

where S: StatementLike + 'b, I: IntoIterator<Item = P> + Send + 'b, I::IntoIter: Send, P: Into<Params> + Send,

Executes the given statement for each item in the given params iterator.

It’ll prepare stmt (once), if necessary.

Provided Methods

fn query<'a, T, Q>(&'a mut self, query: Q) -> BoxFuture<'a, Result<Vec<T>>>

where Q: AsQuery + 'a, T: FromRow + Send + 'static,

Performs the given query and collects the first result set.

Conversion

This stream will convert each row into T using FromRow implementation. If the row type is unknown please use the Row type for T to make this conversion infallible.

fn query_first<'a, T, Q>( &'a mut self, query: Q, ) -> BoxFuture<'a, Result<Option<T>>>

where Q: AsQuery + 'a, T: FromRow + Send + 'static,

Performs the given query and returns the first row of the first result set.

Conversion

This stream will convert each row into T using FromRow implementation. If the row type is unknown please use the Row type for T to make this conversion infallible.

fn query_map<'a, T, F, Q, U>( &'a mut self, query: Q, f: F, ) -> BoxFuture<'a, Result<Vec<U>>>

where Q: AsQuery + 'a, T: FromRow + Send + 'static, F: FnMut(T) -> U + Send + 'a, U: Send,

Performs the given query and maps each row of the first result set.

Conversion

This stream will convert each row into T using FromRow implementation. If the row type is unknown please use the Row type for T to make this conversion infallible.

fn query_fold<'a, T, F, Q, U>( &'a mut self, query: Q, init: U, f: F, ) -> BoxFuture<'a, Result<U>>

where Q: AsQuery + 'a, T: FromRow + Send + 'static, F: FnMut(U, T) -> U + Send + 'a, U: Send + 'a,

Performs the given query and folds the first result set to a single value.

Conversion

This stream will convert each row into T using FromRow implementation. If the row type is unknown please use the Row type for T to make this conversion infallible.

fn query_drop<'a, Q>(&'a mut self, query: Q) -> BoxFuture<'a, Result<()>>

where Q: AsQuery + 'a,

Performs the given query and drops the query result.

fn exec<'a: 'b, 'b, T, S, P>( &'a mut self, stmt: S, params: P, ) -> BoxFuture<'b, Result<Vec<T>>>

where S: StatementLike + 'b, P: Into<Params> + Send + 'b, T: FromRow + Send + 'static,

Executes the given statement and collects the first result set.

It’ll prepare stmt, if necessary.

Conversion

This stream will convert each row into T using FromRow implementation. If the row type is unknown please use the Row type for T to make this conversion infallible.

fn exec_first<'a: 'b, 'b, T, S, P>( &'a mut self, stmt: S, params: P, ) -> BoxFuture<'b, Result<Option<T>>>

where S: StatementLike + 'b, P: Into<Params> + Send + 'b, T: FromRow + Send + 'static,

Executes the given statement and returns the first row of the first result set.

It’ll prepare stmt, if necessary.

Conversion

This stream will convert each row into T using FromRow implementation. If the row type is unknown please use the Row type for T to make this conversion infallible.

fn exec_map<'a: 'b, 'b, T, S, P, U, F>( &'a mut self, stmt: S, params: P, f: F, ) -> BoxFuture<'b, Result<Vec<U>>>

where S: StatementLike + 'b, P: Into<Params> + Send + 'b, T: FromRow + Send + 'static, F: FnMut(T) -> U + Send + 'a, U: Send + 'a,

Executes the given stmt and maps each row of the first result set.

It’ll prepare stmt, if necessary.

Conversion

This stream will convert each row into T using FromRow implementation. If the row type is unknown please use the Row type for T to make this conversion infallible.

fn exec_fold<'a: 'b, 'b, T, S, P, U, F>( &'a mut self, stmt: S, params: P, init: U, f: F, ) -> BoxFuture<'b, Result<U>>

where S: StatementLike + 'b, P: Into<Params> + Send + 'b, T: FromRow + Send + 'static, F: FnMut(U, T) -> U + Send + 'a, U: Send + 'a,

Executes the given stmt and folds the first result set to a signel value.

It’ll prepare stmt, if necessary.

Conversion

This stream will convert each row into T using FromRow implementation. If the row type is unknown please use the Row type for T to make this conversion infallible.

fn exec_drop<'a: 'b, 'b, S, P>( &'a mut self, stmt: S, params: P, ) -> BoxFuture<'b, Result<()>>

where S: StatementLike + 'b, P: Into<Params> + Send + 'b,

Executes the given statement and drops the result.

fn query_stream<'a, T, Q>( &'a mut self, query: Q, ) -> BoxFuture<'a, Result<ResultSetStream<'a, 'a, 'static, T, TextProtocol>>>

where T: Unpin + FromRow + Send + 'static, Q: AsQuery + 'a,

Returns a stream over the first result set.

Please see QueryResult::stream_and_drop.

fn exec_stream<'a: 's, 's, T, Q, P>( &'a mut self, stmt: Q, params: P, ) -> BoxFuture<'s, Result<ResultSetStream<'a, 'a, 'static, T, BinaryProtocol>>>

where T: Unpin + FromRow + Send + 'static, Q: StatementLike + 'a, P: Into<Params> + Send + 's,

Returns a stream over the first result set.

Please see QueryResult::stream_and_drop.

Object Safety

This trait is not object safe.

Implementors

impl Queryable for Conn

impl Queryable for Transaction<'_>