Struct ReaderBuilder 

pub struct ReaderBuilder {
    batch_size: usize,
    coerce_primitive: bool,
    strict_mode: bool,
    ignore_type_conflicts: bool,
    is_field: bool,
    struct_mode: StructMode,
    flatten_top_level_arrays: bool,
    decoder_factory: Option<Arc<dyn DecoderFactory>>,
    schema: SchemaRef,
}

A builder for Reader and Decoder

Fields

batch_size: usize

coerce_primitive: bool

strict_mode: bool

ignore_type_conflicts: bool

is_field: bool

struct_mode: StructMode

flatten_top_level_arrays: bool

decoder_factory: Option<Arc<dyn DecoderFactory>>

schema: SchemaRef

Implementations

impl ReaderBuilder

pub fn new(schema: SchemaRef) -> Self

Create a new ReaderBuilder with the provided [SchemaRef]

This could be obtained using infer_json_schema if not known

Any columns not present in schema will be ignored, unless strict_mode is set to true. In this case, an error is returned when a column is missing from schema.

pub fn new_with_field(field: impl Into<FieldRef>) -> Self

Create a new ReaderBuilder that will parse JSON values of field.data_type()

Unlike ReaderBuilder::new this does not require the root of the JSON data to be an object, i.e. {..}, allowing for parsing of any valid JSON value(s)

// Root of JSON schema is a numeric type
let data = "1\n2\n3\n";
let field = Arc::new(Field::new("int", DataType::Int32, true));
let mut reader = ReaderBuilder::new_with_field(field.clone()).build(data.as_bytes()).unwrap();
let b = reader.next().unwrap().unwrap();
let values = b.column(0).as_primitive::<Int32Type>().values();
assert_eq!(values, &[1, 2, 3]);

// Root of JSON schema is a list type
let data = "[1, 2, 3, 4, 5, 6, 7]\n[1, 2, 3]";
let field = Field::new_list("int", field.clone(), true);
let mut reader = ReaderBuilder::new_with_field(field).build(data.as_bytes()).unwrap();
let b = reader.next().unwrap().unwrap();
let list = b.column(0).as_list::<i32>();

assert_eq!(list.offsets().as_ref(), &[0, 7, 10]);
let list_values = list.values().as_primitive::<Int32Type>();
assert_eq!(list_values.values(), &[1, 2, 3, 4, 5, 6, 7, 1, 2, 3]);

pub fn with_batch_size(self, batch_size: usize) -> Self

Sets the batch size in rows to read

pub fn with_coerce_primitive(self, coerce_primitive: bool) -> Self

Sets if the decoder should coerce primitive values (bool and number) into string when the Schema’s column is Utf8 or LargeUtf8.

pub fn with_strict_mode(self, strict_mode: bool) -> Self

Sets if the decoder should return an error if it encounters a column not present in schema. If struct_mode is ListOnly the value of strict_mode is effectively true. It is required for all fields of the struct to be in the list: without field names, there is no way to determine which field is missing.

pub fn with_struct_mode(self, struct_mode: StructMode) -> Self

Set the StructMode for the reader, which determines whether structs can be decoded from JSON as objects or lists. For more details refer to the enum documentation. Default is to use ObjectOnly.

pub fn with_ignore_type_conflicts(self, ignore_type_conflicts: bool) -> Self

Sets whether the decoder should produce NULL instead of returning an error if it encounters value that can not be parsed into the specified column type.

For example, if the type is declared to be a nullable array of DataType::Int32 but the reader encounters a string value "foo" and the value ignore_type_conflicts is:

• false (the default): The reader will return an error.

• true: The reader will fill in NULL value for that array element.

NOTE: An inferred NULL due to a type conflict will still produce parsing errors for non-nullable fields, the same as any other NULL or missing value.

pub fn with_flatten(self, flatten_top_level_arrays: bool) -> Self

Sets whether to flatten top-level arrays.

• When true, each element of a top-level array will be treated as its own row.
• When false (the default), the entire top-level array will be treated as one row.

For example, consider this input file:

[{ "a": 1 }, { "a": 2 }, { "b": 3 }]
[{ "a": 4 }, { "a": 5 }, { "b": 6 }]

By default, this would be parsed as two rows, each an array containing three elements. With this option set to true, however, this would be parsed as six rows.

Note that even with this option set to true, top-level objects are still permitted and will be parsed as individual rows in the exact same manner as when this option is set to false. It is even possible to mix top-level arrays with top-level objects.

pub fn with_decoder_factory( self, decoder_factory: Arc<dyn DecoderFactory>, ) -> Self

Set a hook for customizing decoding behavior. See DecoderFactory.

pub fn build<R: BufRead>(self, reader: R) -> Result<Reader<R>, ArrowError>

Create a Reader with the provided BufRead

pub fn build_decoder(self) -> Result<Decoder, ArrowError>

Create a Decoder

Trait Implementations

impl Clone for ReaderBuilder

fn clone(&self) -> ReaderBuilder

Returns a duplicate of the value.

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

Performs copy-assignment from source.