Struct polars::prelude::datatypes::Field

pub struct Field {
    pub name: SmartString<LazyCompact>,
    pub dtype: DataType,
}

Characterizes the name and the DataType of a column.

Fields

name: SmartString<LazyCompact>

dtype: DataType

Implementations

impl Field

pub fn new(name: &str, dtype: DataType) -> Field

Creates a new Field.

Example

let f1 = Field::new("Fruit name", DataType::String);
let f2 = Field::new("Lawful", DataType::Boolean);
let f2 = Field::new("Departure", DataType::Time);

pub fn from_owned(name: SmartString<LazyCompact>, dtype: DataType) -> Field

pub fn name(&self) -> &SmartString<LazyCompact>

Returns a reference to the Field name.

Example

let f = Field::new("Year", DataType::Int32);

assert_eq!(f.name(), "Year");

pub fn data_type(&self) -> &DataType

Returns a reference to the Field datatype.

Example

let f = Field::new("Birthday", DataType::Date);

assert_eq!(f.data_type(), &DataType::Date);

pub fn coerce(&mut self, dtype: DataType)

Sets the Field datatype.

Example

let mut f = Field::new("Temperature", DataType::Int32);
f.coerce(DataType::Float32);

assert_eq!(f, Field::new("Temperature", DataType::Float32));

pub fn set_name(&mut self, name: SmartString<LazyCompact>)

Sets the Field name.

Example

let mut f = Field::new("Atomic number", DataType::UInt32);
f.set_name("Proton".into());

assert_eq!(f, Field::new("Proton", DataType::UInt32));

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

Converts the Field to an arrow::datatypes::Field.

Example

let f = Field::new("Value", DataType::Int64);
let af = arrow::datatypes::Field::new("Value", arrow::datatypes::ArrowDataType::Int64, true);

assert_eq!(f.to_arrow(true), af);

Trait Implementations

impl AsRef<DataType> for Field

fn as_ref(&self) -> &DataType

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Field

fn clone(&self) -> Field

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Field

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

Formats the value using the given formatter.

impl<'a> From<&AnyValue<'a>> for Field

fn from(val: &AnyValue<'a>) -> Field

Converts to this type from the input type.

impl From<&Field> for Field

fn from(f: &Field) -> Field

Converts to this type from the input type.

impl Hash for Field

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 PartialEq for Field

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

impl StructuralPartialEq for Field