Struct Blob

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

Available on crate feature blob only.

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<'_>

fn drop(&mut self)

Executes the destructor for this type.

impl Read for Blob<'_>

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.

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

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

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.

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

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

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

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

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

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Reads the exact number of bytes required to fill cursor.

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

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

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

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

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

where Self: Sized,

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

impl Seek for Blob<'_>

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

Seek to an offset, in bytes, in BLOB.

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream.

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

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

Returns the length of this stream (in bytes).

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

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

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

Seeks relative to the current position.

impl Write for Blob<'_>

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.

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

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

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(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

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 write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

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

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

where Self: Sized,

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