Struct diesel::serialize::Output

pub struct Output<'a, 'b, DB>
where
    DB: Backend,
    DB::MetadataLookup: 'a,
{ /* private fields */ }

Wraps a buffer to be written by ToSql with additional backend specific utilities.

Implementations

impl<'a, 'b, DB: Backend> Output<'a, 'b, DB>

pub fn new( out: <DB::BindCollector<'a> as BindCollector<'a, DB>>::Buffer, metadata_lookup: &'b mut DB::MetadataLookup, ) -> Self

Construct a new Output

pub fn into_inner( self, ) -> <DB::BindCollector<'a> as BindCollector<'a, DB>>::Buffer

Consume the current Output structure to access the inner buffer type

This function is only useful for people implementing their own Backend.

pub fn metadata_lookup(&mut self) -> &mut DB::MetadataLookup

Returns the backend’s mechanism for dynamically looking up type metadata at runtime, if relevant for the given backend.

pub fn set_value<V>(&mut self, value: V)

where V: Into<<DB::BindCollector<'a> as BindCollector<'a, DB>>::Buffer>,

Set the inner buffer to a specific value

Checkout the documentation of the type of BindCollector::Buffer for your specific backend for supported types.

impl<'a, 'b, DB> Output<'a, 'b, DB>

where for<'c> DB: Backend<BindCollector<'c> = RawBytesBindCollector<DB>>,

pub fn reborrow<'c>(&'c mut self) -> Output<'c, 'c, DB>

where 'a: 'c,

Call this method whenever you pass an instance of Output<DB> by value.

Effectively copies self, with a narrower lifetime. When passing a reference or a mutable reference, this is normally done by rust implicitly. This is why you can pass &mut Foo to multiple functions, even though mutable references are not Copy. However, this is only done implicitly for references. For structs with lifetimes it must be done explicitly. This method matches the semantics of what Rust would do implicitly if you were passing a mutable reference

Trait Implementations

impl<'a, 'b, DB> Debug for Output<'a, 'b, DB>

where <DB::BindCollector<'a> as BindCollector<'a, DB>>::Buffer: Debug, DB: Backend,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, 'b, DB> Write for Output<'a, 'b, DB>

where for<'c> DB: Backend<BindCollector<'c> = RawBytesBindCollector<DB>>,

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_all(&mut self, buf: &[u8]) -> Result<()>

Attempts to write an entire buffer into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<()>

Writes a formatted string into this writer, returning any error encountered.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.