Struct sqlx_core::raw_sql::RawSql

pub struct RawSql<'q>(/* private fields */);

One or more raw SQL statements, separated by semicolons (;).

See raw_sql() for details.

Implementations

impl<'q> RawSql<'q>

pub async fn execute<'e, E>( self, executor: E, ) -> Result<<E::Database as Database>::QueryResult>

where E: Executor<'e>, 'q: 'e,

Execute the SQL string and return the total number of rows affected.

pub fn execute_many<'e, E>( self, executor: E, ) -> BoxStream<'e, Result<<E::Database as Database>::QueryResult>>

where E: Executor<'e>, 'q: 'e,

Execute the SQL string. Returns a stream which gives the number of rows affected for each statement in the string.

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

where E: Executor<'e>, 'q: 'e,

Execute the SQL string and return the generated results as a stream.

If the string contains multiple statements, their results will be concatenated together.

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

where E: Executor<'e>, 'q: 'e,

Execute the SQL string 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, E>( self, executor: E, ) -> Result<Vec<<E::Database as Database>::Row>>

where E: Executor<'e>, 'q: 'e,

Execute the SQL string 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, E>( self, executor: E, ) -> Result<<E::Database as Database>::Row>

where E: Executor<'e>, 'q: 'e,

Execute the SQL string, 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, E>( self, executor: E, ) -> Result<<E::Database as Database>::Row>

where E: Executor<'e>, 'q: 'e,

Execute the SQL string, 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> Execute<'q, DB> for RawSql<'q>

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.