Struct TableStrategy 

pub struct TableStrategy { /* private fields */ }

A configurable strategy for writing nested tabular data, dispatching each (sub)stream to the structural writer for its dtype.

Dispatch rules, applied to the dtype of the stream handed to write_stream:

• struct → StructStrategy, with each field written by its override (if any) or by a descended copy of this dispatcher.
• list → ListLayoutStrategy, with elements written by a descended copy of this dispatcher (so nested structs/lists recurse) and offsets/validity by the leaf/validity strategies. Gated: only when list decomposition is enabled via with_list_layout (off by default); otherwise a list falls through to the leaf strategy.
• anything else → the leaf strategy.

Implementations

impl TableStrategy

pub fn new( validity: Arc<dyn LayoutStrategy>, fallback: Arc<dyn LayoutStrategy>, ) -> Self

Create a new dispatcher with the given validity strategy and fallback leaf strategy and no overrides.

Additional per-field overrides can be configured with with_field_writer.

Example

// Build a write strategy that does not compress validity or any leaf fields.
let flat = Arc::new(FlatLayoutStrategy::default());

let strategy = TableStrategy::new(Arc::<FlatLayoutStrategy>::clone(&flat), Arc::<FlatLayoutStrategy>::clone(&flat));

pub fn with_field_writer( self, field_path: impl Into<FieldPath>, writer: Arc<dyn LayoutStrategy>, ) -> Self

Add a custom write strategy for the given leaf field.

Example

// A strategy for compressing data using the balanced BtrBlocks compressor.
let compress =
    CompressingStrategy::new(FlatLayoutStrategy::default(), BtrBlocksCompressor::default());

// Our combined strategy uses no compression for validity buffers, BtrBlocks compression
// for most columns, and stores a nested binary column uncompressed (flat) because it
// is pre-compressed or never filtered on.
let strategy = TableStrategy::new(
        Arc::new(FlatLayoutStrategy::default()),
        Arc::new(compress),
    )
    .with_field_writer(
        field_path!(request.body.bytes),
        Arc::new(FlatLayoutStrategy::default()),
    );

pub fn with_field_writers( self, writers: impl IntoIterator<Item = (FieldPath, Arc<dyn LayoutStrategy>)>, ) -> Self

Set writers for several fields at once.

See also: with_field_writer.

pub fn with_default_strategy(self, default: Arc<dyn LayoutStrategy>) -> Self

Override the default strategy for leaf columns that don’t have overrides.

pub fn with_validity_strategy(self, validity: Arc<dyn LayoutStrategy>) -> Self

Override the strategy for compressing struct validity at all levels of the schema tree.

pub fn with_list_layout(self) -> Self

Enable writing list fields with ListLayoutStrategy.

Note: this is an unstable and experimental layout that is expected to change. Using it may lead to unreadable files in the future.

pub fn with_list_layout_factory( self, factory: impl Fn(ListLayoutStrategy) -> Arc<dyn LayoutStrategy> + Send + Sync + 'static, ) -> Self

Enable writing list fields with ListLayoutStrategy and wrap each list writer. This allows repartitioning or zoning to operate in the list’s outer-row space before shredding.

Note: this is an unstable and experimental layout that is expected to change. Using it may lead to unreadable files in the future.

Trait Implementations

impl LayoutStrategy for TableStrategy

Dispatches each stream to the structural writer for its dtype.

fn write_stream<'life0, 'life1, 'async_trait>( &'life0 self, ctx: ArrayContext, segment_sink: SegmentSinkRef, stream: SendableSequentialStream, eof: SequencePointer, session: &'life1 VortexSession, ) -> Pin<Box<dyn Future<Output = VortexResult<LayoutRef>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Asynchronously process an ordered stream of array chunks, emitting them into a sink and returning the Layout instance that can be parsed to retrieve the data from rest.

fn buffered_bytes(&self) -> u64

Returns the number of bytes currently buffered by this strategy and any child strategies.