217 lines
5.8 KiB
Rust
Executable File
217 lines
5.8 KiB
Rust
Executable File
//! Provides [`Encode`] for encoding values for the database.
|
|
|
|
use std::borrow::Cow;
|
|
use std::mem;
|
|
use std::rc::Rc;
|
|
use std::sync::Arc;
|
|
|
|
use crate::database::Database;
|
|
use crate::error::BoxDynError;
|
|
|
|
/// The return type of [Encode::encode].
|
|
#[must_use]
|
|
pub enum IsNull {
|
|
/// The value is null; no data was written.
|
|
Yes,
|
|
|
|
/// The value is not null.
|
|
///
|
|
/// This does not mean that data was written.
|
|
No,
|
|
}
|
|
|
|
impl IsNull {
|
|
pub fn is_null(&self) -> bool {
|
|
matches!(self, IsNull::Yes)
|
|
}
|
|
}
|
|
|
|
/// Encode a single value to be sent to the database.
|
|
pub trait Encode<'q, DB: Database> {
|
|
/// Writes the value of `self` into `buf` in the expected format for the database.
|
|
fn encode(self, buf: &mut <DB as Database>::ArgumentBuffer) -> Result<IsNull, BoxDynError>
|
|
where
|
|
Self: Sized,
|
|
{
|
|
self.encode_by_ref(buf)
|
|
}
|
|
|
|
/// Writes the value of `self` into `buf` without moving `self`.
|
|
///
|
|
/// Where possible, make use of `encode` instead as it can take advantage of re-using
|
|
/// memory.
|
|
fn encode_by_ref(
|
|
&self,
|
|
buf: &mut <DB as Database>::ArgumentBuffer,
|
|
) -> Result<IsNull, BoxDynError>;
|
|
|
|
fn produces(&self) -> Option<DB::TypeInfo> {
|
|
// `produces` is inherently a hook to allow database drivers to produce value-dependent
|
|
// type information; if the driver doesn't need this, it can leave this as `None`
|
|
None
|
|
}
|
|
|
|
#[inline]
|
|
fn size_hint(&self) -> usize {
|
|
mem::size_of_val(self)
|
|
}
|
|
}
|
|
|
|
impl<'q, T, DB: Database> Encode<'q, DB> for &'_ T
|
|
where
|
|
T: Encode<'q, DB>,
|
|
{
|
|
#[inline]
|
|
fn encode(self, buf: &mut <DB as Database>::ArgumentBuffer) -> Result<IsNull, BoxDynError> {
|
|
<T as Encode<DB>>::encode_by_ref(self, buf)
|
|
}
|
|
|
|
#[inline]
|
|
fn encode_by_ref(
|
|
&self,
|
|
buf: &mut <DB as Database>::ArgumentBuffer,
|
|
) -> Result<IsNull, BoxDynError> {
|
|
<&T as Encode<DB>>::encode(self, buf)
|
|
}
|
|
|
|
#[inline]
|
|
fn produces(&self) -> Option<DB::TypeInfo> {
|
|
(**self).produces()
|
|
}
|
|
|
|
#[inline]
|
|
fn size_hint(&self) -> usize {
|
|
(**self).size_hint()
|
|
}
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! impl_encode_for_option {
|
|
($DB:ident) => {
|
|
impl<'q, T> $crate::encode::Encode<'q, $DB> for Option<T>
|
|
where
|
|
T: $crate::encode::Encode<'q, $DB> + $crate::types::Type<$DB> + 'q,
|
|
{
|
|
#[inline]
|
|
fn produces(&self) -> Option<<$DB as $crate::database::Database>::TypeInfo> {
|
|
if let Some(v) = self {
|
|
v.produces()
|
|
} else {
|
|
T::type_info().into()
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn encode(
|
|
self,
|
|
buf: &mut <$DB as $crate::database::Database>::ArgumentBuffer,
|
|
) -> Result<$crate::encode::IsNull, $crate::error::BoxDynError> {
|
|
if let Some(v) = self {
|
|
v.encode(buf)
|
|
} else {
|
|
Ok($crate::encode::IsNull::Yes)
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn encode_by_ref(
|
|
&self,
|
|
buf: &mut <$DB as $crate::database::Database>::ArgumentBuffer,
|
|
) -> Result<$crate::encode::IsNull, $crate::error::BoxDynError> {
|
|
if let Some(v) = self {
|
|
v.encode_by_ref(buf)
|
|
} else {
|
|
Ok($crate::encode::IsNull::Yes)
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn size_hint(&self) -> usize {
|
|
self.as_ref().map_or(0, $crate::encode::Encode::size_hint)
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! impl_encode_for_smartpointer {
|
|
($smart_pointer:ty) => {
|
|
impl<'q, T, DB: Database> Encode<'q, DB> for $smart_pointer
|
|
where
|
|
T: Encode<'q, DB>,
|
|
{
|
|
#[inline]
|
|
fn encode(
|
|
self,
|
|
buf: &mut <DB as Database>::ArgumentBuffer,
|
|
) -> Result<IsNull, BoxDynError> {
|
|
<T as Encode<DB>>::encode_by_ref(self.as_ref(), buf)
|
|
}
|
|
|
|
#[inline]
|
|
fn encode_by_ref(
|
|
&self,
|
|
buf: &mut <DB as Database>::ArgumentBuffer,
|
|
) -> Result<IsNull, BoxDynError> {
|
|
<&T as Encode<DB>>::encode(self, buf)
|
|
}
|
|
|
|
#[inline]
|
|
fn produces(&self) -> Option<DB::TypeInfo> {
|
|
(**self).produces()
|
|
}
|
|
|
|
#[inline]
|
|
fn size_hint(&self) -> usize {
|
|
(**self).size_hint()
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
impl_encode_for_smartpointer!(Arc<T>);
|
|
impl_encode_for_smartpointer!(Box<T>);
|
|
impl_encode_for_smartpointer!(Rc<T>);
|
|
|
|
impl<'q, T, DB: Database> Encode<'q, DB> for Cow<'q, T>
|
|
where
|
|
T: Encode<'q, DB>,
|
|
T: ToOwned,
|
|
{
|
|
#[inline]
|
|
fn encode(self, buf: &mut <DB as Database>::ArgumentBuffer) -> Result<IsNull, BoxDynError> {
|
|
<&T as Encode<DB>>::encode_by_ref(&self.as_ref(), buf)
|
|
}
|
|
|
|
#[inline]
|
|
fn encode_by_ref(
|
|
&self,
|
|
buf: &mut <DB as Database>::ArgumentBuffer,
|
|
) -> Result<IsNull, BoxDynError> {
|
|
<&T as Encode<DB>>::encode_by_ref(&self.as_ref(), buf)
|
|
}
|
|
|
|
#[inline]
|
|
fn produces(&self) -> Option<DB::TypeInfo> {
|
|
<&T as Encode<DB>>::produces(&self.as_ref())
|
|
}
|
|
|
|
#[inline]
|
|
fn size_hint(&self) -> usize {
|
|
<&T as Encode<DB>>::size_hint(&self.as_ref())
|
|
}
|
|
}
|
|
|
|
#[macro_export]
|
|
macro_rules! forward_encode_impl {
|
|
($for_type:ty, $forward_to:ty, $db:ident) => {
|
|
impl<'q> Encode<'q, $db> for $for_type {
|
|
fn encode_by_ref(
|
|
&self,
|
|
buf: &mut <$db as sqlx_core::database::Database>::ArgumentBuffer,
|
|
) -> Result<IsNull, BoxDynError> {
|
|
<$forward_to as Encode<$db>>::encode(self.as_ref(), buf)
|
|
}
|
|
}
|
|
};
|
|
}
|