Struct Field

pub struct Field {
    pub name: String,
    pub id: i32,
    pub parent_id: i32,
    pub logical_type: LogicalType,
    pub metadata: HashMap<String, String>,
    pub encoding: Option<Encoding>,
    pub nullable: bool,
    pub children: Vec<Field>,
    pub dictionary: Option<Dictionary>,
    pub storage_class: StorageClass,
    pub unenforced_primary_key: bool,
}

Lance Schema Field

Fields

name: String

id: i32

parent_id: i32

logical_type: LogicalType

metadata: HashMap<String, String>

encoding: Option<Encoding>

nullable: bool

children: Vec<Field>

dictionary: Option<Dictionary>

Dictionary value array if this field is dictionary.

storage_class: StorageClass

unenforced_primary_key: bool

Implementations

impl Field

pub fn new_arrow( name: &str, data_type: DataType, nullable: bool, ) -> Result<Field, Error>

Shortcut for creating a field with no field id (i.e. from the same info needed to create an Arrow field)

pub fn data_type(&self) -> DataType

Returns arrow data type.

pub fn has_dictionary_types(&self) -> bool

pub fn is_default_storage(&self) -> bool

pub fn storage_class(&self) -> StorageClass

pub fn merge_with_reference(&self, other: &Field, reference: &Field) -> Field

Merge a field with another field using a reference field to ensure the correct order of fields

For each child in the reference field we look for a matching child in self and other.

If we find a match in both we recursively merge the children. If we find a match in one but not the other we take the matching child.

Primitive fields we simply clone self and return.

Matches are determined using field names and so ids are not required.

pub fn apply_projection(&self, projection: &Projection) -> Option<Field>

pub fn explain_difference( &self, expected: &Field, options: &SchemaCompareOptions, ) -> Option<String>

pub fn compare_nullability( expected_nullability: bool, actual_nullability: bool, options: &SchemaCompareOptions, ) -> bool

pub fn compare_with_options( &self, expected: &Field, options: &SchemaCompareOptions, ) -> bool

pub fn extension_name(&self) -> Option<&str>

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

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

pub fn set_dictionary_values(&mut self, arr: &Arc<dyn Array>)

Attach the Dictionary’s value array, so that we can later serialize the dictionary to the manifest.

pub fn set_dictionary(&mut self, arr: &Arc<dyn Array>)

pub fn sub_field(&self, path_components: &[&str]) -> Option<&Field>

pub fn sub_field_mut(&mut self, path_components: &[&str]) -> Option<&mut Field>

pub fn is_blob(&self) -> bool

Check if the user has labeled the field as a blob

Blob fields will load descriptions by default

pub fn into_unloaded(self) -> Field

If the field is a blob, return a new field with the same name and id but with the data type set to a struct of the blob description fields.

If the field is not a blob, return the field itself.

pub fn project(&self, path_components: &[&str]) -> Result<Field, Error>

pub fn project_by_filter<F>(&self, filter: &F) -> Option<Field>

where F: Fn(&Field) -> bool,

Create a new field by removing all fields that do not match the filter.

If a child field matches the filter then the parent will be kept even if it does not match the filter.

Returns None if the field itself does not match the filter.

pub fn project_by_field( &self, other: &Field, on_type_mismatch: OnTypeMismatch, ) -> Result<Field, Error>

Project by a field.

pub fn intersection(&self, other: &Field) -> Result<Field, Error>

Intersection of two Fields.

pub fn intersection_ignore_types(&self, other: &Field) -> Result<Field, Error>

Intersection of two Fields, ignoring data types.

pub fn exclude(&self, other: &Field) -> Option<Field>

pub fn set_id(&mut self, parent_id: i32, id_seed: &mut i32)

Recursively set field ID and parent ID for this field and all its children.

pub fn field_by_id_mut(&mut self, id: impl Into<i32>) -> Option<&mut Field>

pub fn field_by_id(&self, id: impl Into<i32>) -> Option<&Field>

pub fn is_packed_struct(&self) -> bool

pub fn is_leaf(&self) -> bool

Return true if the field is a leaf field.

A leaf field is a field that is not a struct or a list.

Trait Implementations

impl Clone for Field

fn clone(&self) -> Field

Returns a duplicate 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 DeepSizeOf for Field

fn deep_size_of_children(&self, context: &mut Context) -> usize

Returns an estimation of the heap-managed storage of this object. This does not include the size of the object itself.

fn deep_size_of(&self) -> usize

Returns an estimation of a total size of memory owned by the object, including heap-managed storage.

impl Display for Field

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

Formats the value using the given formatter.

impl From<&Field> for Field

fn from(field: &Field) -> Field

Converts to this type from the input type.

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 TryFrom<&Field> for Field

type Error = Error

The type returned in the event of a conversion error.

fn try_from(field: &Field) -> Result<Field, Error>

Performs the conversion.

impl TryFrom<Field> for Field

type Error = Error

The type returned in the event of a conversion error.

fn try_from(field: Field) -> Result<Field, Error>

Performs the conversion.

impl StructuralPartialEq for Field