Struct arrow_schema::Schema

source ·

pub struct Schema {
    pub fields: Fields,
    pub metadata: HashMap<String, String>,
}

Expand description

Describes the meta-data of an ordered sequence of relative types.

Note that this information is only part of the meta-data and not part of the physical memory layout.

Fields§

§fields: Fields§metadata: HashMap<String, String>

A map of key-value pairs containing additional meta data.

Implementations§

source §

impl Schema

source

pub fn empty() -> Self

Creates an empty Schema

source

pub fn new(fields: impl Into<Fields>) -> Self

Creates a new Schema from a sequence of Field values.

Example

let field_a = Field::new("a", DataType::Int64, false);
let field_b = Field::new("b", DataType::Boolean, false);

let schema = Schema::new(vec![field_a, field_b]);

source

pub fn new_with_metadata( fields: impl Into<Fields>, metadata: HashMap<String, String> ) -> Self

Creates a new Schema from a sequence of Field values and adds additional metadata in form of key value pairs.

Example


let field_a = Field::new("a", DataType::Int64, false);
let field_b = Field::new("b", DataType::Boolean, false);

let mut metadata: HashMap<String, String> = HashMap::new();
metadata.insert("row_count".to_string(), "100".to_string());

let schema = Schema::new_with_metadata(vec![field_a, field_b], metadata);

source

pub fn with_metadata(self, metadata: HashMap<String, String>) -> Self

Sets the metadata of this Schema to be metadata and returns self

source

pub fn project(&self, indices: &[usize]) -> Result<Schema, ArrowError>

Returns a new schema with only the specified columns in the new schema This carries metadata from the parent schema over as well

source

pub fn try_merge( schemas: impl IntoIterator<Item = Self> ) -> Result<Self, ArrowError>

Merge schema into self if it is compatible. Struct fields will be merged recursively.

Example:


let merged = Schema::try_merge(vec![
    Schema::new(vec![
        Field::new("c1", DataType::Int64, false),
        Field::new("c2", DataType::Utf8, false),
    ]),
    Schema::new(vec![
        Field::new("c1", DataType::Int64, true),
        Field::new("c2", DataType::Utf8, false),
        Field::new("c3", DataType::Utf8, false),
    ]),
]).unwrap();

assert_eq!(
    merged,
    Schema::new(vec![
        Field::new("c1", DataType::Int64, true),
        Field::new("c2", DataType::Utf8, false),
        Field::new("c3", DataType::Utf8, false),
    ]),
);

source

pub const fn fields(&self) -> &Fields

Returns an immutable reference of the vector of Field instances.

source

pub fn all_fields(&self) -> Vec<&Field>

Returns a vector with references to all fields (including nested fields)

source

pub fn field(&self, i: usize) -> &Field

Returns an immutable reference of a specific Field instance selected using an offset within the internal fields vector.

source

pub fn field_with_name(&self, name: &str) -> Result<&Field, ArrowError>

Returns an immutable reference of a specific Field instance selected by name.

source

pub fn fields_with_dict_id(&self, dict_id: i64) -> Vec<&Field>

Returns a vector of immutable references to all Field instances selected by the dictionary ID they use.

source

pub fn index_of(&self, name: &str) -> Result<usize, ArrowError>

Find the index of the column with the given name.

source

pub const fn metadata(&self) -> &HashMap<String, String>

Returns an immutable reference to the Map of custom metadata key-value pairs.

source

pub fn column_with_name(&self, name: &str) -> Option<(usize, &Field)>

Look up a column by name and return a immutable reference to the column along with its index.

source

pub fn contains(&self, other: &Schema) -> bool

Check to see if self is a superset of other schema.

In particular returns true if self.metadata is a superset of other.metadata and Fields::contains for self.fields and other.fields

In other words, any record that conforms to other should also conform to self.

source

pub fn remove(&mut self, index: usize) -> FieldRef

Remove field by index and return it. Recommend to use SchemaBuilder if you are looking to remove multiple columns, as this will save allocations.

Panic

Panics if index is out of bounds.

Example

use arrow_schema::{DataType, Field, Schema};
let mut schema = Schema::new(vec![
  Field::new("a", DataType::Boolean, false),
  Field::new("b", DataType::Int8, false),
  Field::new("c", DataType::Utf8, false),
]);
assert_eq!(schema.fields.len(), 3);
assert_eq!(schema.remove(1), Field::new("b", DataType::Int8, false).into());
assert_eq!(schema.fields.len(), 2);