Struct polars::prelude::Schema

pub struct Schema { /* private fields */ }

A map from field/column name (String) to the type of that field/column (DataType)

Implementations

impl Schema

pub fn new() -> Schema

Create a new, empty schema

pub fn with_capacity(capacity: usize) -> Schema

Create a new, empty schema with capacity

If you know the number of fields you have ahead of time, using this is more efficient than using new. Also consider using Schema::from_iter if you have the collection of fields available ahead of time.

pub fn reserve(&mut self, additional: usize)

Reserve additional memory spaces in the schema.

pub fn len(&self) -> usize

The number of fields in the schema

pub fn is_empty(&self) -> bool

pub fn rename( &mut self, old: &str, new: SmartString<LazyCompact> ) -> Option<SmartString<LazyCompact>>

Rename field old to new, and return the (owned) old name

If old is not present in the schema, the schema is not modified and None is returned. Otherwise the schema is updated and Some(old_name) is returned.

pub fn new_inserting_at_index( &self, index: usize, name: SmartString<LazyCompact>, dtype: DataType ) -> Result<Schema, PolarsError>

Create a new schema from this one, inserting a field with name and dtype at the given index

If a field named name already exists, it is updated with the new dtype. Regardless, the field named name is always moved to the given index. Valid indices range from 0 (front of the schema) to self.len() (after the end of the schema).

For a mutating version that doesn’t clone, see insert_at_index.

Runtime: O(m * n) where m is the (average) length of the field names and n is the number of fields in the schema. This method clones every field in the schema.

Returns: Ok(new_schema) if index <= self.len(), else Err(PolarsError)

pub fn insert_at_index( &mut self, index: usize, name: SmartString<LazyCompact>, dtype: DataType ) -> Result<Option<DataType>, PolarsError>

Insert a field with name and dtype at the given index into this schema

If a field named name already exists, it is updated with the new dtype. Regardless, the field named name is always moved to the given index. Valid indices range from 0 (front of the schema) to self.len() (after the end of the schema).

For a non-mutating version that clones the schema, see new_inserting_at_index.

Runtime: O(n) where n is the number of fields in the schema.

Returns:

• If index is out of bounds, Err(PolarsError)
• Else if name was already in the schema, Ok(Some(old_dtype))
• Else Ok(None)

pub fn get(&self, name: &str) -> Option<&DataType>

Get a reference to the dtype of the field named name, or None if the field doesn’t exist

pub fn try_get(&self, name: &str) -> Result<&DataType, PolarsError>

Get a reference to the dtype of the field named name, or Err(PolarsErr) if the field doesn’t exist

pub fn try_get_mut(&mut self, name: &str) -> Result<&mut DataType, PolarsError>

Get a mutable reference to the dtype of the field named name, or Err(PolarsErr) if the field doesn’t exist

pub fn get_full( &self, name: &str ) -> Option<(usize, &SmartString<LazyCompact>, &DataType)>

Return all data about the field named name: its index in the schema, its name, and its dtype

Returns Some((index, &name, &dtype)) if the field exists, None if it doesn’t.

pub fn try_get_full( &self, name: &str ) -> Result<(usize, &SmartString<LazyCompact>, &DataType), PolarsError>

Return all data about the field named name: its index in the schema, its name, and its dtype

Returns Ok((index, &name, &dtype)) if the field exists, Err(PolarsErr) if it doesn’t.

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

Look up the name in the schema and return an owned Field by cloning the data

Returns None if the field does not exist.

This method constructs the Field by cloning the name and dtype. For a version that returns references, see get or get_full.

pub fn try_get_field(&self, name: &str) -> Result<Field, PolarsError>

Look up the name in the schema and return an owned Field by cloning the data

Returns Err(PolarsErr) if the field does not exist.

This method constructs the Field by cloning the name and dtype. For a version that returns references, see get or get_full.

pub fn get_at_index( &self, index: usize ) -> Option<(&SmartString<LazyCompact>, &DataType)>

Get references to the name and dtype of the field at index

If index is inbounds, returns Some((&name, &dtype)), else None. See get_at_index_mut for a mutable version.

pub fn try_get_at_index( &self, index: usize ) -> Result<(&SmartString<LazyCompact>, &DataType), PolarsError>

pub fn get_at_index_mut( &mut self, index: usize ) -> Option<(&mut SmartString<LazyCompact>, &mut DataType)>

Get mutable references to the name and dtype of the field at index

If index is inbounds, returns Some((&mut name, &mut dtype)), else None. See get_at_index for an immutable version.

pub fn remove(&mut self, name: &str) -> Option<DataType>

Swap-remove a field by name and, if the field existed, return its dtype

If the field does not exist, the schema is not modified and None is returned.

This method does a swap_remove, which is O(1) but changes the order of the schema: the field named name is replaced by the last field, which takes its position. For a slower, but order-preserving, method, use shift_remove.

pub fn shift_remove(&mut self, name: &str) -> Option<DataType>

Remove a field by name, preserving order, and, if the field existed, return its dtype

If the field does not exist, the schema is not modified and None is returned.

This method does a shift_remove, which preserves the order of the fields in the schema but is O(n). For a faster, but not order-preserving, method, use remove.

pub fn shift_remove_index( &mut self, index: usize ) -> Option<(SmartString<LazyCompact>, DataType)>

Remove a field by name, preserving order, and, if the field existed, return its dtype

If the field does not exist, the schema is not modified and None is returned.

This method does a shift_remove, which preserves the order of the fields in the schema but is O(n). For a faster, but not order-preserving, method, use remove.

pub fn contains(&self, name: &str) -> bool

Whether the schema contains a field named name

pub fn set_dtype(&mut self, name: &str, dtype: DataType) -> Option<DataType>

Change the field named name to the given dtype and return the previous dtype

If name doesn’t already exist in the schema, the schema is not modified and None is returned. Otherwise returns Some(old_dtype).

This method only ever modifies an existing field and never adds a new field to the schema. To add a new field, use with_column or insert_at_index.

pub fn set_dtype_at_index( &mut self, index: usize, dtype: DataType ) -> Option<DataType>

Change the field at the given index to the given dtype and return the previous dtype

If the index is out of bounds, the schema is not modified and None is returned. Otherwise returns Some(old_dtype).

This method only ever modifies an existing index and never adds a new field to the schema. To add a new field, use with_column or insert_at_index.

pub fn with_column( &mut self, name: SmartString<LazyCompact>, dtype: DataType ) -> Option<DataType>

Insert a new column in the Schema

If an equivalent name already exists in the schema: the name remains and retains in its place in the order, its corresponding value is updated with DataType and the older dtype is returned inside Some(_).

If no equivalent key existed in the map: the new name-dtype pair is inserted, last in order, and None is returned.

To enforce the index of the resulting field, use insert_at_index.

Computes in O(1) time (amortized average).

pub fn merge(&mut self, other: Schema)

Merge other into self

Merging logic:

• Fields that occur in self but not other are unmodified
• Fields that occur in other but not self are appended, in order, to the end of self
• Fields that occur in both self and other are updated with the dtype from other, but keep their original index

pub fn merge_from_ref(&mut self, other: &Schema)

Merge borrowed other into self

Merging logic:

• Fields that occur in self but not other are unmodified
• Fields that occur in other but not self are appended, in order, to the end of self
• Fields that occur in both self and other are updated with the dtype from other, but keep their original index

pub fn to_arrow(&self, pl_flavor: bool) -> ArrowSchema

Convert self to ArrowSchema by cloning the fields

pub fn iter_fields(&self) -> impl ExactSizeIterator

Iterates the Fields in this schema, constructing them anew by cloning each (&name, &dtype) pair

Note that this clones each name and dtype in order to form an owned Field. For a clone-free version, use iter, which returns (&name, &dtype).

pub fn iter_dtypes(&self) -> impl ExactSizeIterator

Iterates over references to the dtypes in this schema

pub fn iter_dtypes_mut(&mut self) -> impl ExactSizeIterator

Iterates over mut references to the dtypes in this schema

pub fn iter_names(&self) -> impl ExactSizeIterator

Iterates over references to the names in this schema

pub fn iter( &self ) -> impl Iterator<Item = (&SmartString<LazyCompact>, &DataType)>

Iterates over the (&name, &dtype) pairs in this schema

For an owned version, use iter_fields, which clones the data to iterate owned Fields

pub fn to_supertype(&mut self, other: &Schema) -> Result<bool, PolarsError>

Take another Schema and try to find the supertypes between them.

Trait Implementations

impl Clone for Schema

fn clone(&self) -> Schema

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Schema

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

Formats the value using the given formatter.

impl Default for Schema

fn default() -> Schema

Returns the “default value” for a type.

impl From<&[Series]> for Schema

fn from(value: &[Series]) -> Schema

Converts to this type from the input type.

impl From<&Arc<ArrowSchema>> for Schema

fn from(value: &Arc<ArrowSchema>) -> Schema

Converts to this type from the input type.

impl From<&ArrowSchema> for Schema

fn from(value: &ArrowSchema) -> Schema

Converts to this type from the input type.

impl From<&Row<'_>> for Schema

fn from(row: &Row<'_>) -> Schema

Converts to this type from the input type.

impl From<&Schema> for DataFrame

fn from(schema: &Schema) -> DataFrame

Converts to this type from the input type.

impl From<Arc<ArrowSchema>> for Schema

fn from(value: Arc<ArrowSchema>) -> Schema

Converts to this type from the input type.

impl From<ArrowSchema> for Schema

fn from(value: ArrowSchema) -> Schema

Converts to this type from the input type.

impl<F> FromIterator<F> for Schema

where F: Into<Field>,

fn from_iter<T>(iter: T) -> Schema

where T: IntoIterator<Item = F>,

Creates a value from an iterator.

impl Hash for Schema

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

where H: Hasher,

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 IndexOfSchema for Schema

fn index_of(&self, name: &str) -> Option<usize>

Get the index of a column by name.

fn get_names(&self) -> Vec<&str>

Get a vector of all column names.

fn try_index_of(&self, name: &str) -> Result<usize, PolarsError>

impl IntoIterator for Schema

type Item = (SmartString<LazyCompact>, DataType)

The type of the elements being iterated over.

type IntoIter = <IndexMap<SmartString<LazyCompact>, DataType, RandomState> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Schema as IntoIterator>::IntoIter

Creates an iterator from a value.

impl PartialEq for Schema

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Schema