Struct deltalake::datafusion::common::Column

pub struct Column {
    pub relation: Option<TableReference<'static>>,
    pub name: String,
}

A named reference to a qualified field in a schema.

Fields

relation: Option<TableReference<'static>>

relation/table reference.

name: String

field/column name.

Implementations

impl Column

pub fn new( relation: Option<impl Into<TableReference<'static>>>, name: impl Into<String> ) -> Column

Create Column from optional qualifier and name. The optional qualifier, if present, will be parsed and normalized by default.

See full details on TableReference::parse_str

pub fn new_unqualified(name: impl Into<String>) -> Column

Convenience method for when there is no qualifier

pub fn from_name(name: impl Into<String>) -> Column

Create Column from unqualified name.

pub fn from_qualified_name(flat_name: impl Into<String>) -> Column

Deserialize a fully qualified name string into a column

Treats the name as a SQL identifier. For example foo.BAR would be parsed to a reference to relation foo, column name bar (lower case) where "foo.BAR" would be parsed to a reference to column named foo.BAR

pub fn from_qualified_name_ignore_case(flat_name: impl Into<String>) -> Column

Deserialize a fully qualified name string into a column preserving column text case

pub fn flat_name(&self) -> String

Serialize column into a flat name string

pub fn quoted_flat_name(&self) -> String

Serialize column into a quoted flat name string

pub fn normalize_with_schemas( self, schemas: &[&Arc<DFSchema>], using_columns: &[HashSet<Column>] ) -> Result<Column, DataFusionError>

👎Deprecated since 20.0.0: use normalize_with_schemas_and_ambiguity_check instead

Qualify column if not done yet.

If this column already has a relation, it will be returned as is and the given parameters are ignored. Otherwise this will search through the given schemas to find the column. This will use the first schema that matches.

A schema matches if there is a single column that – when unqualified – matches this column. There is an exception for USING statements, see below.

Using columns

Take the following SQL statement:

SELECT id FROM t1 JOIN t2 USING(id)

In this case, both t1.id and t2.id will match unqualified column id. To express this possibility, use using_columns. Each entry in this array is a set of columns that are bound together via a USING clause. So in this example this would be [{t1.id, t2.id}].

pub fn normalize_with_schemas_and_ambiguity_check( self, schemas: &[&[&DFSchema]], using_columns: &[HashSet<Column>] ) -> Result<Column, DataFusionError>

Qualify column if not done yet.

If this column already has a relation, it will be returned as is and the given parameters are ignored. Otherwise this will search through the given schemas to find the column.

Will check for ambiguity at each level of schemas.

A schema matches if there is a single column that – when unqualified – matches this column. There is an exception for USING statements, see below.

Using columns

Take the following SQL statement:

SELECT id FROM t1 JOIN t2 USING(id)

In this case, both t1.id and t2.id will match unqualified column id. To express this possibility, use using_columns. Each entry in this array is a set of columns that are bound together via a USING clause. So in this example this would be [{t1.id, t2.id}].

Regarding ambiguity check, schemas is structured to allow levels of schemas to be passed in. For example:

schemas = &[
   &[schema1, schema2], // first level
   &[schema3, schema4], // second level
]

Will search for a matching field in all schemas in the first level. If a matching field according to above mentioned conditions is not found, then will check the next level. If found more than one matching column across all schemas in a level, that isn’t a USING column, will return an error due to ambiguous column.

If checked all levels and couldn’t find field, will return field not found error.

Trait Implementations

impl Clone for Column

fn clone(&self) -> Column

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Column

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

Formats the value using the given formatter.

impl Display for Column

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

Formats the value using the given formatter.

impl From<&Column> for Column

fn from(c: &Column) -> Column

Converts to this type from the input type.

impl From<&String> for Column

Create a column, cloning the string

fn from(c: &String) -> Column

Converts to this type from the input type.

impl From<&str> for Column

fn from(c: &str) -> Column

Converts to this type from the input type.

impl From<Column> for Column

fn from(c: Column) -> Column

Converts to this type from the input type.

impl From<Column> for DeltaColumn

Create a column, resuing the existing datafusion column

fn from(c: Column) -> DeltaColumn

Converts to this type from the input type.

impl From<DeltaColumn> for Column

fn from(value: DeltaColumn) -> Column

Converts to this type from the input type.

impl From<String> for Column

Create a column, reusing the existing string

fn from(c: String) -> Column

Converts to this type from the input type.

impl FromStr for Column

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Column, <Column as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for Column

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 Ord for Column

fn cmp(&self, other: &Column) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Column

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

fn partial_cmp(&self, other: &Column) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Column

impl StructuralPartialEq for Column