Struct ParquetObjectWriter

pub struct ParquetObjectWriter {
    w: BufWriter,
}

ParquetObjectWriter for writing to parquet to [ObjectStore]

    let store = Arc::new(InMemory::new());

    let col = Arc::new(Int64Array::from_iter_values([1, 2, 3])) as ArrayRef;
    let to_write = RecordBatch::try_from_iter([("col", col)]).unwrap();

    let object_store_writer = ParquetObjectWriter::new(store.clone(), Path::from("test"));
    let mut writer =
        AsyncArrowWriter::try_new(object_store_writer, to_write.schema(), None).unwrap();
    writer.write(&to_write).await.unwrap();
    writer.close().await.unwrap();

    let buffer = store
        .get(&Path::from("test"))
        .await
        .unwrap()
        .bytes()
        .await
        .unwrap();
    let mut reader = ParquetRecordBatchReaderBuilder::try_new(buffer)
        .unwrap()
        .build()
        .unwrap();
    let read = reader.next().unwrap().unwrap();

    assert_eq!(to_write, read);

Fields

w: BufWriter

Implementations

impl ParquetObjectWriter

pub fn new(store: Arc<dyn ObjectStore>, path: Path) -> Self

Create a new ParquetObjectWriter that writes to the specified path in the given store.

To configure the writer behavior, please build [BufWriter] and then use Self::from_buf_writer

pub fn from_buf_writer(w: BufWriter) -> Self

Construct a new ParquetObjectWriter via a existing BufWriter.

pub fn into_inner(self) -> BufWriter

Consume the writer and return the underlying BufWriter.

Trait Implementations

impl AsyncFileWriter for ParquetObjectWriter

fn write(&mut self, bs: Bytes) -> BoxFuture<'_, Result<()>>

Write the provided bytes to the underlying writer

fn complete(&mut self) -> BoxFuture<'_, Result<()>>

Flush any buffered data to the underlying writer and finish writing process.

impl Debug for ParquetObjectWriter

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

Formats the value using the given formatter.

impl From<BufWriter> for ParquetObjectWriter

fn from(w: BufWriter) -> Self

Converts to this type from the input type.