Struct Sqlite
pub struct Sqlite;Expand description
Sqlite database driver.
Trait Implementations§
§impl Database for Sqlite
 
impl Database for Sqlite
§const URL_SCHEMES: &'static [&'static str]
 
const URL_SCHEMES: &'static [&'static str]
The schemes for database URLs that should match this driver.
§type Connection = SqliteConnection
 
type Connection = SqliteConnection
The concrete 
Connection implementation for this database.§type TransactionManager = SqliteTransactionManager
 
type TransactionManager = SqliteTransactionManager
The concrete 
TransactionManager implementation for this database.§type QueryResult = SqliteQueryResult
 
type QueryResult = SqliteQueryResult
The concrete 
QueryResult implementation for this database.§type Column = SqliteColumn
 
type Column = SqliteColumn
The concrete 
Column implementation for this database.§type TypeInfo = SqliteTypeInfo
 
type TypeInfo = SqliteTypeInfo
The concrete 
TypeInfo implementation for this database.§type Value = SqliteValue
 
type Value = SqliteValue
The concrete type used to hold an owned copy of the not-yet-decoded value that was
received from the database.
§type ValueRef<'r> = SqliteValueRef<'r>
 
type ValueRef<'r> = SqliteValueRef<'r>
The concrete type used to hold a reference to the not-yet-decoded value that has just been
received from the database.
§type Arguments<'q> = SqliteArguments<'q>
 
type Arguments<'q> = SqliteArguments<'q>
The concrete 
Arguments implementation for this database.§type ArgumentBuffer<'q> = Vec<SqliteArgumentValue<'q>>
 
type ArgumentBuffer<'q> = Vec<SqliteArgumentValue<'q>>
The concrete type used as a buffer for arguments while encoding.
§type Statement<'q> = SqliteStatement<'q>
 
type Statement<'q> = SqliteStatement<'q>
The concrete 
Statement implementation for this database.§impl Decode<'_, Sqlite> for Hyphenated
 
impl Decode<'_, Sqlite> for Hyphenated
§fn decode(
    value: SqliteValueRef<'_>,
) -> Result<Hyphenated, Box<dyn Error + Sync + Send>>
 
fn decode( value: SqliteValueRef<'_>, ) -> Result<Hyphenated, Box<dyn Error + Sync + Send>>
Decode a new value of this type using a raw value from the database.
§impl<'r> Decode<'r, Sqlite> for NaiveDateTime
 
impl<'r> Decode<'r, Sqlite> for NaiveDateTime
§fn decode(
    value: SqliteValueRef<'r>,
) -> Result<NaiveDateTime, Box<dyn Error + Sync + Send>>
 
fn decode( value: SqliteValueRef<'r>, ) -> Result<NaiveDateTime, Box<dyn Error + Sync + Send>>
Decode a new value of this type using a raw value from the database.
§impl<'r> Decode<'r, Sqlite> for DateTime<FixedOffset>
 
impl<'r> Decode<'r, Sqlite> for DateTime<FixedOffset>
§fn decode(
    value: SqliteValueRef<'r>,
) -> Result<DateTime<FixedOffset>, Box<dyn Error + Sync + Send>>
 
fn decode( value: SqliteValueRef<'r>, ) -> Result<DateTime<FixedOffset>, Box<dyn Error + Sync + Send>>
Decode a new value of this type using a raw value from the database.
§impl<'r, T> Decode<'r, Sqlite> for Json<T>where
    T: 'r + Deserialize<'r>,
 
impl<'r, T> Decode<'r, Sqlite> for Json<T>where
    T: 'r + Deserialize<'r>,
§impl<'r> Decode<'r, Sqlite> for PrimitiveDateTime
 
impl<'r> Decode<'r, Sqlite> for PrimitiveDateTime
§fn decode(
    value: SqliteValueRef<'r>,
) -> Result<PrimitiveDateTime, Box<dyn Error + Sync + Send>>
 
fn decode( value: SqliteValueRef<'r>, ) -> Result<PrimitiveDateTime, Box<dyn Error + Sync + Send>>
Decode a new value of this type using a raw value from the database.
§impl<'r> Decode<'r, Sqlite> for OffsetDateTime
 
impl<'r> Decode<'r, Sqlite> for OffsetDateTime
§fn decode(
    value: SqliteValueRef<'r>,
) -> Result<OffsetDateTime, Box<dyn Error + Sync + Send>>
 
fn decode( value: SqliteValueRef<'r>, ) -> Result<OffsetDateTime, Box<dyn Error + Sync + Send>>
Decode a new value of this type using a raw value from the database.
§impl Encode<'_, Sqlite> for Box<[u8]>
 
impl Encode<'_, Sqlite> for Box<[u8]>
§fn encode(
    self,
    args: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode( self, args: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
Writes the value of 
self into buf in the expected format for the database.§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl Encode<'_, Sqlite> for Box<str>
 
impl Encode<'_, Sqlite> for Box<str>
§fn encode(
    self,
    args: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode( self, args: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
Writes the value of 
self into buf in the expected format for the database.§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl Encode<'_, Sqlite> for NaiveDate
 
impl Encode<'_, Sqlite> for NaiveDate
§fn encode_by_ref(
    &self,
    buf: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, buf: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl Encode<'_, Sqlite> for NaiveDateTime
 
impl Encode<'_, Sqlite> for NaiveDateTime
§fn encode_by_ref(
    &self,
    buf: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, buf: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<Tz> Encode<'_, Sqlite> for DateTime<Tz>
 
impl<Tz> Encode<'_, Sqlite> for DateTime<Tz>
§fn encode_by_ref(
    &self,
    buf: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, buf: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<T> Encode<'_, Sqlite> for Json<T>where
    T: Serialize,
 
impl<T> Encode<'_, Sqlite> for Json<T>where
    T: Serialize,
§fn encode_by_ref(
    &self,
    buf: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, buf: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl Encode<'_, Sqlite> for NaiveTime
 
impl Encode<'_, Sqlite> for NaiveTime
§fn encode_by_ref(
    &self,
    buf: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, buf: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl Encode<'_, Sqlite> for Date
 
impl Encode<'_, Sqlite> for Date
§fn encode_by_ref(
    &self,
    buf: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, buf: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl Encode<'_, Sqlite> for PrimitiveDateTime
 
impl Encode<'_, Sqlite> for PrimitiveDateTime
§fn encode_by_ref(
    &self,
    buf: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, buf: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl Encode<'_, Sqlite> for OffsetDateTime
 
impl Encode<'_, Sqlite> for OffsetDateTime
§fn encode_by_ref(
    &self,
    buf: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, buf: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl Encode<'_, Sqlite> for Time
 
impl Encode<'_, Sqlite> for Time
§fn encode_by_ref(
    &self,
    buf: &mut Vec<SqliteArgumentValue<'_>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, buf: &mut Vec<SqliteArgumentValue<'_>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for &'q [u8]
 
impl<'q> Encode<'q, Sqlite> for &'q [u8]
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for &'q str
 
impl<'q> Encode<'q, Sqlite> for &'q str
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for Cow<'q, str>
 
impl<'q> Encode<'q, Sqlite> for Cow<'q, str>
§fn encode(
    self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode( self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
Writes the value of 
self into buf in the expected format for the database.§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for Hyphenated
 
impl<'q> Encode<'q, Sqlite> for Hyphenated
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q, T> Encode<'q, Sqlite> for Option<T>
 
impl<'q, T> Encode<'q, Sqlite> for Option<T>
fn produces(&self) -> Option<<Sqlite as Database>::TypeInfo>
§fn encode(
    self,
    buf: &mut <Sqlite as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode( self, buf: &mut <Sqlite as Database>::ArgumentBuffer<'q>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
Writes the value of 
self into buf in the expected format for the database.§fn encode_by_ref(
    &self,
    buf: &mut <Sqlite as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, buf: &mut <Sqlite as Database>::ArgumentBuffer<'q>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for Simple
 
impl<'q> Encode<'q, Sqlite> for Simple
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for String
 
impl<'q> Encode<'q, Sqlite> for String
§fn encode(
    self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode( self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
Writes the value of 
self into buf in the expected format for the database.§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q, T> Encode<'q, Sqlite> for Text<T>where
    T: Display,
 
impl<'q, T> Encode<'q, Sqlite> for Text<T>where
    T: Display,
§fn encode_by_ref(
    &self,
    buf: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, buf: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for Uuid
 
impl<'q> Encode<'q, Sqlite> for Uuid
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for Vec<u8>
 
impl<'q> Encode<'q, Sqlite> for Vec<u8>
§fn encode(
    self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode( self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
Writes the value of 
self into buf in the expected format for the database.§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for bool
 
impl<'q> Encode<'q, Sqlite> for bool
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for f32
 
impl<'q> Encode<'q, Sqlite> for f32
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for f64
 
impl<'q> Encode<'q, Sqlite> for f64
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for i16
 
impl<'q> Encode<'q, Sqlite> for i16
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for i32
 
impl<'q> Encode<'q, Sqlite> for i32
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for i64
 
impl<'q> Encode<'q, Sqlite> for i64
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for i8
 
impl<'q> Encode<'q, Sqlite> for i8
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for u16
 
impl<'q> Encode<'q, Sqlite> for u16
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for u32
 
impl<'q> Encode<'q, Sqlite> for u32
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> Encode<'q, Sqlite> for u8
 
impl<'q> Encode<'q, Sqlite> for u8
§fn encode_by_ref(
    &self,
    args: &mut Vec<SqliteArgumentValue<'q>>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
 
fn encode_by_ref( &self, args: &mut Vec<SqliteArgumentValue<'q>>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
§fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
 
fn encode(
    self,
    buf: &mut <DB as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, Box<dyn Error + Sync + Send>>where
    Self: Sized,
Writes the value of 
self into buf in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
§impl<'q> IntoArguments<'q, Sqlite> for SqlxValues
 
impl<'q> IntoArguments<'q, Sqlite> for SqlxValues
fn into_arguments(self) -> SqliteArguments<'q>
§impl Type<Sqlite> for [u8]
 
impl Type<Sqlite> for [u8]
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for Box<[u8]>
 
impl Type<Sqlite> for Box<[u8]>
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for Box<str>
 
impl Type<Sqlite> for Box<str>
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§impl Type<Sqlite> for Cow<'_, str>
 
impl Type<Sqlite> for Cow<'_, str>
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for NaiveDate
 
impl Type<Sqlite> for NaiveDate
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for NaiveDateTime
 
impl Type<Sqlite> for NaiveDateTime
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl<Tz> Type<Sqlite> for DateTime<Tz>where
    Tz: TimeZone,
 
impl<Tz> Type<Sqlite> for DateTime<Tz>where
    Tz: TimeZone,
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for Hyphenated
 
impl Type<Sqlite> for Hyphenated
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§impl<T> Type<Sqlite> for Json<T>
 
impl<T> Type<Sqlite> for Json<T>
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for Simple
 
impl Type<Sqlite> for Simple
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§impl Type<Sqlite> for String
 
impl Type<Sqlite> for String
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§impl<T> Type<Sqlite> for Text<T>
 
impl<T> Type<Sqlite> for Text<T>
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for NaiveTime
 
impl Type<Sqlite> for NaiveTime
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for Date
 
impl Type<Sqlite> for Date
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for PrimitiveDateTime
 
impl Type<Sqlite> for PrimitiveDateTime
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for OffsetDateTime
 
impl Type<Sqlite> for OffsetDateTime
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for Time
 
impl Type<Sqlite> for Time
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for Uuid
 
impl Type<Sqlite> for Uuid
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for Vec<u8>
 
impl Type<Sqlite> for Vec<u8>
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for bool
 
impl Type<Sqlite> for bool
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for f32
 
impl Type<Sqlite> for f32
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§impl Type<Sqlite> for f64
 
impl Type<Sqlite> for f64
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§impl Type<Sqlite> for i16
 
impl Type<Sqlite> for i16
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for i32
 
impl Type<Sqlite> for i32
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for i64
 
impl Type<Sqlite> for i64
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for i8
 
impl Type<Sqlite> for i8
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for str
 
impl Type<Sqlite> for str
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§impl Type<Sqlite> for u16
 
impl Type<Sqlite> for u16
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for u32
 
impl Type<Sqlite> for u32
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for u64
 
impl Type<Sqlite> for u64
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl Type<Sqlite> for u8
 
impl Type<Sqlite> for u8
§fn type_info() -> SqliteTypeInfo
 
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
§fn compatible(ty: &SqliteTypeInfo) -> bool
 
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
§impl TypeChecking for Sqlite
 
impl TypeChecking for Sqlite
§const PARAM_CHECKING: ParamChecking = ::sqlx_core::type_checking::ParamChecking::Weak
 
const PARAM_CHECKING: ParamChecking = ::sqlx_core::type_checking::ParamChecking::Weak
Describes how the database in question typechecks query parameters.
§fn param_type_for_id(
    info: &<Sqlite as Database>::TypeInfo,
) -> Option<&'static str>
 
fn param_type_for_id( info: &<Sqlite as Database>::TypeInfo, ) -> Option<&'static str>
Get the full path of the Rust type that corresponds to the given 
TypeInfo, if applicable. Read more§fn return_type_for_id(
    info: &<Sqlite as Database>::TypeInfo,
) -> Option<&'static str>
 
fn return_type_for_id( info: &<Sqlite as Database>::TypeInfo, ) -> Option<&'static str>
Get the full path of the Rust type that corresponds to the given 
TypeInfo, if applicable. Read moreimpl HasStatementCache for Sqlite
Auto Trait Implementations§
impl Freeze for Sqlite
impl RefUnwindSafe for Sqlite
impl Send for Sqlite
impl Sync for Sqlite
impl Unpin for Sqlite
impl UnwindSafe for Sqlite
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
    T: ?Sized,
 
impl<T> BorrowMut<T> for Twhere
    T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
 
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> Instrument for T
 
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
 
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
 
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
 
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
 
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
Converts 
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
 
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
Converts 
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more