Struct FieldPath 

pub struct FieldPath(/* private fields */);

A sequence of field selectors representing a path through zero or more layers of DType.

Examples

The empty path references the root:

use vortex_array::dtype::*;

let dtype_i32 = DType::Primitive(PType::I32, Nullability::NonNullable);
assert_eq!(dtype_i32, FieldPath::root().resolve(dtype_i32.clone()).unwrap());

Implementations

impl FieldPath

pub fn root() -> Self

The selector for the root (i.e., the top-level struct itself)

pub fn from_name<F: Into<FieldName>>(name: F) -> Self

Constructs a new FieldPath from a single field selector (i.e., a direct child field of the top-level struct)

pub fn parts(&self) -> &[Field]

Returns the sequence of field selectors that make up this path

pub fn is_root(&self) -> bool

Returns whether this path is a root path.

pub fn push<F: Into<Field>>(self, field: F) -> Self

Pushes a new field selector to the end of this path

pub fn starts_with_field(&self, field: &Field) -> bool

Whether the path starts with the given field name TODO(joe): handle asserts better.

pub fn step_into(self) -> Option<Self>

Steps into the next field in the path

pub fn resolve(&self, dtype: DType) -> Option<DType>

The dtype, within the given type, to which this field path refers.

Note that a nullable DType may contain a non-nullable DType. This function returns the literal nullability of the child.

Examples

Extract the type of the “b” field from struct{a: list(struct{b: u32})?}:

use std::sync::Arc;

use vortex_array::dtype::*;
use vortex_array::dtype::Nullability::*;

let dtype = DType::Struct(
    StructFields::from_iter([(
        "a",
        DType::List(
            Arc::new(DType::Struct(
                StructFields::from_iter([(
                    "b",
                    DType::Primitive(PType::U32, NonNullable),
                )]),
                NonNullable,
            )),
            Nullable,
        ),
    )]),
    NonNullable,
);

let path = FieldPath::from(vec![Field::from("a"), Field::ElementType, Field::from("b")]);
let resolved = path.resolve(dtype).unwrap();
assert_eq!(resolved, DType::Primitive(PType::U32, NonNullable));

pub fn exists_in(&self, dtype: DType) -> bool

Does the field referenced by the field path exist in the given dtype?

pub fn overlap(&self, other: &FieldPath) -> bool

Returns true if this path overlaps with another path (i.e., one is a prefix of the other).

Trait Implementations

impl Clone for FieldPath

fn clone(&self) -> FieldPath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FieldPath

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

Formats the value using the given formatter.

impl Default for FieldPath

fn default() -> FieldPath

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FieldPath

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for FieldPath

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

Formats the value using the given formatter.

impl From<Field> for FieldPath

fn from(value: Field) -> Self

Converts to this type from the input type.

impl From<Vec<Field>> for FieldPath

fn from(value: Vec<Field>) -> Self

Converts to this type from the input type.

impl FromIterator<Field> for FieldPath

fn from_iter<T: IntoIterator<Item = Field>>(iter: T) -> Self

Creates a value from an iterator.

impl FromIterator<FieldPath> for FieldPathSet

fn from_iter<T: IntoIterator<Item = FieldPath>>(iter: T) -> Self

Creates a value from an iterator.

impl Hash for FieldPath

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

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 FieldPath

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&FieldPath> for FieldPath

type Error = VortexError

The type returned in the event of a conversion error.

fn try_from(value: &FieldPath) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for FieldPath

impl StructuralPartialEq for FieldPath