Struct IpcSchemaEncoder

pub struct IpcSchemaEncoder<'a> {
    dictionary_tracker: Option<&'a mut DictionaryTracker>,
}

Low level Arrow [Schema] to IPC bytes converter

See also fb_to_schema for the reverse operation

Example

// given an arrow schema to serialize
let schema = Schema::new(vec![
   Field::new("a", DataType::Int32, false),
]);

// Use a dictionary tracker to track dictionary id if needed
 let mut dictionary_tracker = DictionaryTracker::new(true);
// create a FlatBuffersBuilder that contains the encoded bytes
 let fb = IpcSchemaEncoder::new()
   .with_dictionary_tracker(&mut dictionary_tracker)
   .schema_to_fb(&schema);

// the bytes are in `fb.finished_data()`
let ipc_bytes = fb.finished_data();

 // convert the IPC bytes back to an Arrow schema
 let ipc_schema = root_as_schema(ipc_bytes).unwrap();
 let schema2 = fb_to_schema(ipc_schema);
assert_eq!(schema, schema2);

Fields

dictionary_tracker: Option<&'a mut DictionaryTracker>

Implementations

impl<'a> IpcSchemaEncoder<'a>

pub fn new() -> IpcSchemaEncoder<'a>

Create a new schema encoder

pub fn with_dictionary_tracker( self, dictionary_tracker: &'a mut DictionaryTracker, ) -> Self

Specify a dictionary tracker to use

pub fn schema_to_fb<'b>(&mut self, schema: &Schema) -> FlatBufferBuilder<'b>

Serialize a schema in IPC format, returning a completed [FlatBufferBuilder]

Note: Call [FlatBufferBuilder::finished_data] to get the serialized bytes

pub fn schema_to_fb_offset<'b>( &mut self, fbb: &mut FlatBufferBuilder<'b>, schema: &Schema, ) -> WIPOffset<Schema<'b>>

Serialize a schema to an in progress [FlatBufferBuilder], returning the in progress offset.

Trait Implementations

impl<'a> Debug for IpcSchemaEncoder<'a>

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

Formats the value using the given formatter.

impl Default for IpcSchemaEncoder<'_>

fn default() -> Self

Returns the “default value” for a type.