Struct oracle::sql_type::Blob

pub struct Blob { /* private fields */ }

A reference to Oracle data type BLOB

This struct implements Read, Write and Seek to read and write bytes; and seek to a position in a LOB.

Examples

use oracle::sql_type::Blob;
use oracle::sql_type::Lob;
use std::io::BufReader;
use std::io::Read;

let sql = "select BLOBCol from TestBLOBS where IntCol = 1";
let mut stmt = conn.statement(sql).lob_locator().build()?;
let blob = stmt.query_row_as::<Blob>(&[])?;
let mut buf_reader = BufReader::with_capacity(blob.chunk_size()? * 16, blob);
let mut buf = [0u8; 4];
assert_eq!(buf_reader.read(&mut buf)?, 4); // read the first four bytes
assert_eq!(&buf, b"BLOB");
assert_eq!(buf_reader.read(&mut buf)?, 4); // read the next four bytes
assert_eq!(&buf, b" DAT");
assert_eq!(buf_reader.read(&mut buf)?, 1); // read the last one byte
assert_eq!(&buf[0..1], b"A");
assert_eq!(buf_reader.read(&mut buf)?, 0); // end of blob

Implementations

impl Blob

pub fn new(conn: &Connection) -> Result<Blob>

Returns a reference to a new temporary LOB which may subsequently be written and bound to a statement.

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

Closes the LOB.

Trait Implementations

impl Clone for Blob

fn clone(&self) -> Blob

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Blob

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

Formats the value using the given formatter.

impl FromSql for Blob

fn from_sql(val: &SqlValue) -> Result<Self>

impl Lob for Blob

fn size(&self) -> Result<u64>

Returns the size of the data stored in the LOB.

fn truncate(&mut self, new_size: u64) -> Result<()>

Shortens the data in the LOB so that it only contains the specified amount of data.

fn chunk_size(&self) -> Result<usize>

Returns the chunk size, in bytes, of the internal LOB. Reading and writing to the LOB in multiples of this size will improve performance.

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

Opens the LOB resource for writing. This will improve performance when writing to the LOB in chunks and there are functional or extensible indexes associated with the LOB. If this function is not called, the LOB resource will be opened and closed for each write that is performed. A call to the close_resource should be done before performing a call to the function Connection.commit.

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

Closes the LOB resource. This should be done when a batch of writes has been completed so that the indexes associated with the LOB can be updated. It should only be performed if a call to function open_resource has been performed.

fn is_resource_open(&self) -> Result<bool>

Returns a boolean value indicating if the LOB resource has been opened by making a call to the function open_resource.

impl Read for Blob

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

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

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

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_string(&mut self, buf: &mut String) -> Result<usize, Error>

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

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

Read 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)

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Selfwhere
    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 a stream.

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.

impl ToSql for Blob

fn oratype(&self, _conn: &Connection) -> Result<OracleType>

fn to_sql(&self, val: &mut SqlValue) -> Result<()>

impl ToSqlNull for Blob

fn oratype_for_null(_conn: &Connection) -> Result<OracleType>

impl Write for Blob

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

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

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

Flush 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, fmt: Arguments<'_>) -> Result<(), Error>

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

fn by_ref(&mut self) -> &mut Selfwhere
    Self: Sized,

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