Struct Field

pub struct Field {
    pub name: PlSmallStr,
    pub dtype: DataType,
}

Characterizes the name and the DataType of a column.

Fields

name: PlSmallStr

dtype: DataType

Implementations

impl Field

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

Creates a new Field.

Example

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

pub fn name(&self) -> &PlSmallStr

Returns a reference to the Field name.

Example

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

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

pub fn dtype(&self) -> &DataType

Returns a reference to the Field datatype.

Example

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

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

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

Sets the Field datatype.

Example

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

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

pub fn set_name(&mut self, name: PlSmallStr)

Sets the Field name.

Example

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

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

pub fn with_name(self, name: PlSmallStr) -> Field

Returns this Field, renamed.

pub fn to_arrow(&self, compat_level: CompatLevel) -> Field

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

Example

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

assert_eq!(f.to_arrow(CompatLevel::newest()), 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<'de> Deserialize<'de> for Field

fn deserialize<__D>( __deserializer: __D, ) -> Result<Field, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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 From<Field> for (PlSmallStr, DataType)

fn from(value: Field) -> (PlSmallStr, DataType)

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Field

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Field

impl StructuralPartialEq for Field