Struct rusqlite::blob::Blob

pub struct Blob<'conn> { /* fields omitted */ }

feature = "blob" Handle to an open BLOB. See rusqlite::blob documentation for in-depth discussion.

Implementations

impl<'conn> Blob<'conn>

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

Write buf to self starting at write_start, returning an error if write_start + buf.len() is past the end of the blob.

If an error is returned, no data is written.

Note: the blob cannot be resized using this function -- that must be done using SQL (for example, an UPDATE statement).

Note: This is part of the positional I/O API, and thus takes an absolute position write to, instead of using the internal position that can be manipulated by the std::io traits.

Unlike the similarly named FileExt::write_at function (from std::os::unix), it's always an error to perform a "short write".

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

An alias for write_at provided for compatibility with the conceptually equivalent std::os::unix::FileExt::write_all_at function from libstd:

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

Read as much as possible from offset to offset + buf.len() out of self, writing into buf. On success, returns the number of bytes written.

If there's insufficient data in self, then the returned value will be less than buf.len().

See also Blob::raw_read_at, which can take an uninitialized buffer, or Blob::read_at_exact which returns an error if the entire buf is not read.

Note: This is part of the positional I/O API, and thus takes an absolute position to read from, instead of using the internal position that can be manipulated by the std::io traits. Consequently, it does not change that value either.

pub fn raw_read_at<'a>(
    &self,
    buf: &'a mut [MaybeUninit<u8>],
    read_start: usize
) -> Result<&'a mut [u8]>

Read as much as possible from offset to offset + buf.len() out of self, writing into buf. On success, returns the portion of buf which was initialized by this call.

If there's insufficient data in self, then the returned value will be shorter than buf.

See also Blob::read_at, which takes a &mut [u8] buffer instead of a slice of MaybeUninit<u8>.

Note: This is part of the positional I/O API, and thus takes an absolute position to read from, instead of using the internal position that can be manipulated by the std::io traits. Consequently, it does not change that value either.

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

Equivalent to Blob::read_at, but returns a BlobSizeError if buf is not fully initialized.

pub fn raw_read_at_exact<'a>(
    &self,
    buf: &'a mut [MaybeUninit<u8>],
    read_start: usize
) -> Result<&'a mut [u8]>

Equivalent to Blob::raw_read_at, but returns a BlobSizeError if buf is not fully initialized.

impl<'_> Blob<'_>

pub fn reopen(&mut self, row: i64) -> Result<()>

Move a BLOB handle to a new row.

Failure

Will return Err if the underlying SQLite BLOB reopen call fails.

pub fn size(&self) -> i32

Return the size in bytes of the BLOB.

pub fn len(&self) -> usize

Return the current size in bytes of the BLOB.

pub fn is_empty(&self) -> bool

Return true if the BLOB is empty.

pub fn close(self) -> Result<()>

Close a BLOB handle.

Calling close explicitly is not required (the BLOB will be closed when the Blob is dropped), but it is available so you can get any errors that occur.

Failure

Will return Err if the underlying SQLite close call fails.

Trait Implementations

impl<'_> Drop for Blob<'_>

pub fn drop(&mut self)

Executes the destructor for this type.

impl<'_> Read for Blob<'_>

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

Read data from a BLOB incrementally. Will return Ok(0) if the end of the blob has been reached.

Failure

Will return Err if the underlying SQLite read call fails.

pub fn read_vectored(
    &mut self,
    bufs: &mut [IoSliceMut<'_>]
) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

pub fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

pub unsafe fn initializer(&self) -> Initializer

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

Determines if this Reader can work with buffers of uninitialized memory.

pub fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

pub fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

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

Read the exact number of bytes required to fill buf.

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

Creates a "by reference" adaptor for this instance of Read.

pub fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

pub fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adaptor which will chain this stream with another.

pub fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.

impl<'_> Seek for Blob<'_>

pub fn seek(&mut self, pos: SeekFrom) -> Result<u64>

Seek to an offset, in bytes, in BLOB.

pub fn stream_len(&mut self) -> Result<u64, Error>

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

Returns the length of this stream (in bytes).

pub fn stream_position(&mut self) -> Result<u64, Error>

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

Returns the current seek position from the start of the stream.

impl<'_> Write for Blob<'_>

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

Write data into a BLOB incrementally. Will return Ok(0) if the end of the blob has been reached; consider using Write::write_all(buf) if you want to get an error if the entirety of the buffer cannot be written.

This function may only modify the contents of the BLOB; it is not possible to increase the size of a BLOB using this API.

Failure

Will return Err if the underlying SQLite write call fails.

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

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

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

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

pub 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.

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

Attempts to write an entire buffer into this writer.

pub 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.

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

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

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

Creates a "by reference" adaptor for this instance of Write.