Struct deltalake::arrow::ipc::writer::StreamWriter

pub struct StreamWriter<W>
where
    W: Write,
{ /* private fields */ }

Implementations

impl<W> StreamWriter<W>

where W: Write,

pub fn try_new( writer: W, schema: &Schema ) -> Result<StreamWriter<W>, ArrowError>

Try create a new writer, with the schema written as part of the header

pub fn try_new_with_options( writer: W, schema: &Schema, write_options: IpcWriteOptions ) -> Result<StreamWriter<W>, ArrowError>

pub fn write(&mut self, batch: &RecordBatch) -> Result<(), ArrowError>

Write a record batch to the stream

pub fn finish(&mut self) -> Result<(), ArrowError>

Write continuation bytes, and mark the stream as done

pub fn get_ref(&self) -> &W

Gets a reference to the underlying writer.

pub fn get_mut(&mut self) -> &mut W

Gets a mutable reference to the underlying writer.

It is inadvisable to directly write to the underlying writer.

pub fn into_inner(self) -> Result<W, ArrowError>

Unwraps the BufWriter housed in StreamWriter.writer, returning the underlying writer

The buffer is flushed and the StreamWriter is finished before returning the writer.

Errors

An [‘Err’] may be returned if an error occurs while finishing the StreamWriter or while flushing the buffer.

Example

// The result we expect from an empty schema
let expected = vec![
    255, 255, 255, 255,  48,   0,   0,   0,
     16,   0,   0,   0,   0,   0,  10,   0,
     12,   0,  10,   0,   9,   0,   4,   0,
     10,   0,   0,   0,  16,   0,   0,   0,
      0,   1,   4,   0,   8,   0,   8,   0,
      0,   0,   4,   0,   8,   0,   0,   0,
      4,   0,   0,   0,   0,   0,   0,   0,
    255, 255, 255, 255,   0,   0,   0,   0
];

let schema = Schema::empty();
let buffer: Vec<u8> = Vec::new();
let options = IpcWriteOptions::try_new(8, false, MetadataVersion::V5)?;
let stream_writer = StreamWriter::try_new_with_options(buffer, &schema, options)?;

assert_eq!(stream_writer.into_inner()?, expected);

Trait Implementations

impl<W> RecordBatchWriter for StreamWriter<W>

where W: Write,

fn write(&mut self, batch: &RecordBatch) -> Result<(), ArrowError>

Write a single batch to the writer.

fn close(self) -> Result<(), ArrowError>

Write footer or termination data, then mark the writer as done.