Struct RecordBatch

pub struct RecordBatch<'a> {
    pub _tab: Table<'a>,
}

A data header describing the shared memory layout of a “record” or “row” batch. Some systems call this a “row batch” internally and others a “record batch”.

Fields

_tab: Table<'a>

Implementations

impl<'a> RecordBatch<'a>

pub const VT_LENGTH: VOffsetT = 4u16

pub const VT_NODES: VOffsetT = 6u16

pub const VT_BUFFERS: VOffsetT = 8u16

pub const VT_COMPRESSION: VOffsetT = 10u16

pub const VT_VARIADICBUFFERCOUNTS: VOffsetT = 12u16

pub unsafe fn init_from_table(table: Table<'a>) -> Self

pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( _fbb: &'mut_bldr mut FlatBufferBuilder<'bldr>, args: &'args RecordBatchArgs<'args>, ) -> WIPOffset<RecordBatch<'bldr>>

pub fn length(&self) -> i64

number of records / rows. The arrays in the batch should all have this length

pub fn nodes(&self) -> Option<Vector<'a, FieldNode>>

Nodes correspond to the pre-ordered flattened logical schema

pub fn buffers(&self) -> Option<Vector<'a, Buffer>>

Buffers correspond to the pre-ordered flattened buffer tree

The number of buffers appended to this list depends on the schema. For example, most primitive arrays will have 2 buffers, 1 for the validity bitmap and 1 for the values. For struct arrays, there will only be a single buffer for the validity (nulls) bitmap

pub fn compression(&self) -> Option<BodyCompression<'a>>

Optional compression of the message body

pub fn variadicBufferCounts(&self) -> Option<Vector<'a, i64>>

Some types such as Utf8View are represented using a variable number of buffers. For each such Field in the pre-ordered flattened logical schema, there will be an entry in variadicBufferCounts to indicate the number of number of variadic buffers which belong to that Field in the current RecordBatch.

For example, the schema col1: Struct<alpha: Int32, beta: BinaryView, gamma: Float64> col2: Utf8View contains two Fields with variadic buffers so variadicBufferCounts will have two entries, the first counting the variadic buffers of col1.beta and the second counting col2’s.

This field may be omitted if and only if the schema contains no Fields with a variable number of buffers, such as BinaryView and Utf8View.

Trait Implementations

impl<'a> Clone for RecordBatch<'a>

fn clone(&self) -> RecordBatch<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RecordBatch<'_>

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

Formats the value using the given formatter.

impl<'a> Follow<'a> for RecordBatch<'a>

type Inner = RecordBatch<'a>

unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner

Safety

impl<'a> PartialEq for RecordBatch<'a>

fn eq(&self, other: &RecordBatch<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Verifiable for RecordBatch<'_>

fn run_verifier( v: &mut Verifier<'_, '_>, pos: usize, ) -> Result<(), InvalidFlatbuffer>

Runs the verifier for this type, assuming its at position pos in the verifier’s buffer. Should not need to be called directly.

impl<'a> Copy for RecordBatch<'a>

impl<'a> StructuralPartialEq for RecordBatch<'a>