[−][src]Struct sqlx::query::Query
Raw SQL query with bind parameters. Returned by query.
Implementations
impl<'q, DB> Query<'q, DB, <DB as HasArguments<'q>>::Arguments> where
DB: Database, [src]
DB: Database,
pub fn bind<T>(
self,
value: T
) -> Query<'q, DB, <DB as HasArguments<'q>>::Arguments> where
T: 'q + Encode<'q, DB> + Type<DB> + Send, [src]
self,
value: T
) -> Query<'q, DB, <DB as HasArguments<'q>>::Arguments> where
T: 'q + Encode<'q, DB> + Type<DB> + Send,
Bind a value for use with this SQL query.
If the number of times this is called does not match the number of bind parameters that
appear in the query (? for most SQL flavors, $1 .. $N for Postgres) then an error
will be returned when this query is executed.
There is no validation that the value is of the type expected by the query. Most SQL flavors will perform type coercion (Postgres will return a database error).
impl<'q, DB, A> Query<'q, DB, A> where
DB: Database + HasStatementCache, [src]
DB: Database + HasStatementCache,
pub fn persistent(self, value: bool) -> Query<'q, DB, A>[src]
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, A> Query<'q, DB, A> where
A: Send + 'q + IntoArguments<'q, DB>,
DB: Database, [src]
A: Send + 'q + IntoArguments<'q, DB>,
DB: Database,
pub fn map<F, O>(self, f: F) -> Map<'q, DB, impl TryMapRow<DB, Output = O>, A> where
F: MapRow<DB, Output = O>,
O: Unpin, [src]
F: MapRow<DB, Output = O>,
O: Unpin,
Map each row in the result to another type.
See try_map for a fallible version of this method.
The query_as method will construct a mapped query using
a FromRow implementation.
pub fn try_map<F>(self, f: F) -> Map<'q, DB, F, A> where
F: TryMapRow<DB>, [src]
F: TryMapRow<DB>,
Map each row in the result to another type.
The query_as method will construct a mapped query using
a FromRow implementation.
pub async fn execute<'e, 'c, E>(
self,
executor: E
) -> Result<<DB as Database>::Done, Error> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>, [src]
self,
executor: E
) -> Result<<DB as Database>::Done, Error> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>,
Execute the query and return the total number of rows affected.
pub async fn execute_many<'e, 'c, E>(
self,
executor: E
) -> Pin<Box<dyn Stream<Item = Result<<DB as Database>::Done, Error>> + 'e + Send, Global>> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>, [src]
self,
executor: E
) -> Pin<Box<dyn Stream<Item = Result<<DB as Database>::Done, Error>> + 'e + Send, Global>> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>,
Execute multiple queries and return the rows affected from each query, in a stream.
pub fn fetch<'e, 'c, E>(
self,
executor: E
) -> Pin<Box<dyn Stream<Item = Result<<DB as Database>::Row, Error>> + 'e + Send, Global>> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>, [src]
self,
executor: E
) -> Pin<Box<dyn Stream<Item = Result<<DB as Database>::Row, Error>> + 'e + Send, Global>> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>,
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>::Done, <DB as Database>::Row>, Error>> + 'e + Send, Global>> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>, [src]
self,
executor: E
) -> Pin<Box<dyn Stream<Item = Result<Either<<DB as Database>::Done, <DB as Database>::Row>, Error>> + 'e + Send, Global>> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>,
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<<DB as Database>::Row, Global>, Error> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>, [src]
self,
executor: E
) -> Result<Vec<<DB as Database>::Row, Global>, Error> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>,
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<<DB as Database>::Row, Error> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>, [src]
self,
executor: E
) -> Result<<DB as Database>::Row, Error> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>,
Execute the query and returns exactly one row.
pub async fn fetch_optional<'e, 'c, E>(
self,
executor: E
) -> Result<Option<<DB as Database>::Row>, Error> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>, [src]
self,
executor: E
) -> Result<Option<<DB as Database>::Row>, Error> where
'c: 'e,
'q: 'e,
A: 'e,
E: Executor<'c, Database = DB>,
Execute the query and returns at most one row.
Trait Implementations
impl<'q, DB, A> Execute<'q, DB> for Query<'q, DB, A> where
A: Send + IntoArguments<'q, DB>,
DB: Database, [src]
A: Send + IntoArguments<'q, DB>,
DB: Database,
pub fn sql(&self) -> &'q str[src]
pub fn statement(&self) -> Option<&<DB as HasStatement<'q>>::Statement>[src]
pub fn take_arguments(&mut self) -> Option<<DB as HasArguments<'q>>::Arguments>[src]
pub fn persistent(&self) -> bool[src]
Auto Trait Implementations
impl<'q, DB, A> RefUnwindSafe for Query<'q, DB, A> where
A: RefUnwindSafe,
DB: RefUnwindSafe,
<DB as HasStatement<'q>>::Statement: RefUnwindSafe, [src]
A: RefUnwindSafe,
DB: RefUnwindSafe,
<DB as HasStatement<'q>>::Statement: RefUnwindSafe,
impl<'q, DB, A> Send for Query<'q, DB, A> where
A: Send,
<DB as HasStatement<'q>>::Statement: Sync, [src]
A: Send,
<DB as HasStatement<'q>>::Statement: Sync,
impl<'q, DB, A> Sync for Query<'q, DB, A> where
A: Sync,
DB: Sync,
<DB as HasStatement<'q>>::Statement: Sync, [src]
A: Sync,
DB: Sync,
<DB as HasStatement<'q>>::Statement: Sync,
impl<'q, DB, A> Unpin for Query<'q, DB, A> where
A: Unpin,
DB: Unpin, [src]
A: Unpin,
DB: Unpin,
impl<'q, DB, A> UnwindSafe for Query<'q, DB, A> where
A: UnwindSafe,
DB: UnwindSafe,
<DB as HasStatement<'q>>::Statement: RefUnwindSafe, [src]
A: UnwindSafe,
DB: UnwindSafe,
<DB as HasStatement<'q>>::Statement: RefUnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T[src]
impl<T> Conv for T
impl<T> Conv for T
impl<T> FmtForward for T
pub fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Self: Binary,
pub fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Self: Display,
pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Self: LowerExp,
pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Self: LowerHex,
pub fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,
Self: Octal,
pub fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Self: Pointer,
pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Self: UpperExp,
pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Self: UpperHex,
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
U: From<T>,
impl<T> Pipe for T where
T: ?Sized,
T: ?Sized,
pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_ref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
pub fn pipe_as_mut<'a, U, R>(
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
pub fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
impl<T> Pipe for T
impl<T> PipeAsRef for T
pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
Self: AsRef<T>,
T: 'a,
R: 'a,
pub fn pipe_as_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
impl<T> PipeBorrow for T
pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
Self: Borrow<T>,
T: 'a,
R: 'a,
pub fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
impl<T> PipeDeref for T
pub fn pipe_deref<'a, R>(
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
pub fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
impl<T> PipeRef for T
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
R: 'a,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> Tap for T
pub fn tap(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
pub fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
impl<T> Tap for T
pub fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
impl<T> TapDeref for T
pub fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
impl<T> TryConv for T
impl<T> TryConv for T
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,