Struct SqlTemplateExecute 

pub struct SqlTemplateExecute<'q, DB: Database> { /* private fields */ }

Internal executor for SQL templates

Implementations

impl<'q, DB: Database> SqlTemplateExecute<'q, DB>

pub fn new(sql: &'q str, arguments: Option<DB::Arguments<'q>>) -> Self

Creates a new SQL template executor

pub fn set_persistent(self, persistent: bool) -> Self

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> SqlTemplateExecute<'q, DB>

where DB: Database + HasStatementCache, DB::Arguments<'q>: IntoArguments<'q, DB>,

pub fn to_query_as<O>(self) -> QueryAs<'q, DB, O, DB::Arguments<'q>>

where O: Send + Unpin + for<'r> FromRow<'r, DB::Row>,

to sqlx_core::QueryAs Converts the SQL template to a QueryAs object, which can be executed to fetch rows

pub fn to_query(self) -> Query<'q, DB, DB::Arguments<'q>>

to sqlx_core::Query Converts the SQL template to a Query object, which can be executed to fetch rows

pub fn map<F, O>( self, f: F, ) -> Map<'q, DB, impl FnMut(DB::Row) -> Result<O, Error> + Send, DB::Arguments<'q>>

where F: FnMut(DB::Row) -> O + Send, O: Unpin,

like sqlx_core::Query::map Map each row in the result to another type.

pub fn try_map<F, O>(self, f: F) -> Map<'q, DB, F, DB::Arguments<'q>>

where F: FnMut(DB::Row) -> Result<O, Error> + Send, O: Unpin,

like sqlx_core::Query::try_map Map each row in the result to another type, returning an error if the mapping fails.

impl<'q, DB> SqlTemplateExecute<'q, DB>

where DB: Database,

pub async fn execute<'e, 'c: 'e, E>( self, executor: E, ) -> Result<DB::QueryResult, Error>

where DB::Arguments<'q>: 'e, E: Executor<'c, Database = DB>, 'q: 'e,

like sqlx_core::Query::execute Execute the query and return the number of rows affected.

pub fn execute_many<'e, 'c: 'e, E>( self, executor: E, ) -> BoxStream<'e, Result<DB::QueryResult, Error>>

where DB::Arguments<'q>: 'e, E: Executor<'c, Database = DB>, 'q: 'e,

like sqlx_core::Query::execute_many Execute multiple queries and return the rows affected from each query, in a stream.

pub fn fetch<'e, 'c: 'e, E>( self, executor: E, ) -> BoxStream<'e, Result<DB::Row, Error>>

where DB::Arguments<'q>: 'e, E: Executor<'c, Database = DB>, 'q: 'e,

like sqlx_core::Query::fetch Execute the query and return the generated results as a stream.

pub fn fetch_many<'e, 'c: 'e, E>( self, executor: E, ) -> BoxStream<'e, Result<Either<DB::QueryResult, DB::Row>, Error>>

where DB::Arguments<'q>: 'e, E: Executor<'c, Database = DB>, 'q: 'e,

like sqlx_core::Query::fetch_many Execute multiple queries and return the generated results as a stream.

For each query in the stream, any generated rows are returned first, then the QueryResult with the number of rows affected.

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

where DB::Arguments<'q>: 'e, E: Executor<'c, Database = DB>, 'q: 'e,

like sqlx_core::Query::fetch_all 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, E>( self, executor: E, ) -> Result<DB::Row, Error>

where DB::Arguments<'q>: 'e, E: Executor<'c, Database = DB>, 'q: 'e,

like sqlx_core::Query::fetch_one 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, E>( self, executor: E, ) -> Result<Option<DB::Row>, Error>

where DB::Arguments<'q>: 'e, E: Executor<'c, Database = DB>, 'q: 'e,

like sqlx_core::Query::fetch_optional 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.

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

where DB::Arguments<'q>: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e, 'q: 'e,

like sqlx_core::QueryAs::fetch Execute the query and return the generated results as a stream.

pub fn fetch_many_as<'e, 'c: 'e, O, E>( self, executor: E, ) -> BoxStream<'e, Result<Either<DB::QueryResult, O>, Error>>

where DB::Arguments<'q>: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e, 'q: 'e,

like sqlx_core::QueryAs::fetch_many Execute multiple queries and return the generated results as a stream from each query, in a stream.

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

where DB::Arguments<'q>: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e, 'q: 'e,

like sqlx_core::QueryAs::fetch_all 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_as<'e, 'c: 'e, O, E>( self, executor: E, ) -> Result<O, Error>

where DB::Arguments<'q>: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e, 'q: 'e,

like sqlx_core::QueryAs::fetch_one 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_as<'e, 'c: 'e, O, E>( self, executor: E, ) -> Result<Option<O>, Error>

where DB::Arguments<'q>: 'e, E: 'e + Executor<'c, Database = DB>, DB: 'e, O: Send + Unpin + for<'r> FromRow<'r, DB::Row> + 'e, 'q: 'e,

like sqlx_core_core::QueryAs::fetch_optional 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: Database> Clone for SqlTemplateExecute<'q, DB>

where DB::Arguments<'q>: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'q, DB: Database> Execute<'q, DB> for SqlTemplateExecute<'q, DB>

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

Returns the SQL query string

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

Gets prepared statement (not supported in this implementation)

fn take_arguments(&mut self) -> Result<Option<DB::Arguments<'q>>, BoxDynError>

Takes ownership of the bound arguments

fn persistent(&self) -> bool

Checks if query is persistent