Struct StreamingParquetCacheWriter 

pub struct StreamingParquetCacheWriter {
    planner: StreamShapePlanner,
    mesh_w: ArrowWriter<Vec<u8>>,
    vert_w: ArrowWriter<Vec<u8>>,
    idx_w: ArrowWriter<Vec<u8>>,
    mesh_count: usize,
}

Incremental whole-model cache writer for the streaming endpoint: each batch’s columns are appended as one Parquet row group per table, so no MeshData has to be retained past the batch that produced it (previously the endpoint kept a FULL second copy of the model’s meshes just to re-serialize them at Complete). The mesh-table vertex_start/index_start columns carry GLOBAL offsets (whole-model), matching what the one-shot serialize_to_parquet emits for the cached fast-path replay.

Fields

planner: StreamShapePlanner

Whole-stream offsets for Self::append’s unshared batches. A cross-batch stream plans with its own planner and hands the result to Self::append_planned, so this one is then never advanced.

mesh_w: ArrowWriter<Vec<u8>>

vert_w: ArrowWriter<Vec<u8>>

idx_w: ArrowWriter<Vec<u8>>

mesh_count: usize

Implementations

impl StreamingParquetCacheWriter

pub fn new(layout: ParquetLayout) -> Result<Self, ParquetError>

pub fn append(&mut self, meshes: &[MeshData]) -> Result<(), ParquetError>

Append one batch, every mesh with its own geometry, as one row group per table at whole-stream offsets. The meshes can be dropped by the caller afterwards.

pub fn append_planned( &mut self, batch: &PlannedBatch, ) -> Result<(), ParquetError>

Append a batch some other StreamShapePlanner already planned (the cross-batch stream, #5407), as one row group per table. The caller’s planner owns the offsets; the tables are written exactly as planned, so the cached blob and the client’s batch agree on every range.

pub fn mesh_count(&self) -> usize

Total meshes appended so far.

pub fn finish_combined(self) -> Result<Bytes, ParquetError>

Close all three writers and assemble the OUTER combined [geo_len][geo_bytes][data_model_len=0] blob the parquet-stream route caches, in one allocation. Equivalent to wrapping finish()’s output with the route’s [geo_len]...[dm_len=0] framing, but without copying the inner geometry blob a second time to do it.