Struct RecordBatch

pub struct RecordBatch {
    pub length: i64,
    pub nodes: Option<Vec<FieldNode>>,
    pub buffers: Option<Vec<Buffer>>,
    pub compression: Option<Box<BodyCompression>>,
    pub variadic_buffer_counts: Option<Vec<i64>>,
}

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”.

Generated from these locations:

• Table RecordBatch in the file Message.fbs:84

Fields

length: i64

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

nodes: Option<Vec<FieldNode>>

Nodes correspond to the pre-ordered flattened logical schema

buffers: Option<Vec<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

compression: Option<Box<BodyCompression>>

Optional compression of the message body

variadic_buffer_counts: Option<Vec<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.

Implementations

impl RecordBatch

pub fn builder() -> RecordBatchBuilder<()>

Creates a RecordBatchBuilder for serializing an instance of this table.

pub fn create( builder: &mut Builder, field_length: impl WriteAsDefault<i64, i64>, field_nodes: impl WriteAsOptional<Offset<[FieldNode]>>, field_buffers: impl WriteAsOptional<Offset<[Buffer]>>, field_compression: impl WriteAsOptional<Offset<BodyCompression>>, field_variadic_buffer_counts: impl WriteAsOptional<Offset<[i64]>>, ) -> Offset<Self>

Trait Implementations

impl Clone for RecordBatch

fn clone(&self) -> RecordBatch

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 Default for RecordBatch

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RecordBatch

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for RecordBatch

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for RecordBatch

fn cmp(&self, other: &RecordBatch) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for RecordBatch

fn eq(&self, other: &RecordBatch) -> 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 PartialOrd for RecordBatch

fn partial_cmp(&self, other: &RecordBatch) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for RecordBatch

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> TryFrom<RecordBatchRef<'a>> for RecordBatch

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: RecordBatchRef<'a>) -> Result<Self>

Performs the conversion.

impl Eq for RecordBatch

impl StructuralPartialEq for RecordBatch

impl VectorWrite<Offset<RecordBatch>> for RecordBatch

Safety

The planus compiler generates implementations that initialize the bytes in write_values.

impl WriteAs<Offset<RecordBatch>> for RecordBatch

impl WriteAsOffset<RecordBatch> for RecordBatch

impl<T0: WriteAsDefault<i64, i64>, T1: WriteAsOptional<Offset<[FieldNode]>>, T2: WriteAsOptional<Offset<[Buffer]>>, T3: WriteAsOptional<Offset<BodyCompression>>, T4: WriteAsOptional<Offset<[i64]>>> WriteAsOffset<RecordBatch> for RecordBatchBuilder<(T0, T1, T2, T3, T4)>

impl WriteAsOptional<Offset<RecordBatch>> for RecordBatch