Struct Column

pub struct Column { /* private fields */ }

Represents the column at a given index in a RecordBatch

This is a physical expression that represents a column at a given index in an arrow Schema / RecordBatch.

Unlike the logical Expr::Column, this expression is always resolved by schema index, even though it does have a name. This is because the physical plan is always resolved to a specific schema and there is no concept of “relation”

Example:

If the schema is a, b, c the Column for b would be represented by index 1, since b is the second colum in the schema.

// Schema with columns a, b, c
let schema = Schema::new(vec![
   Field::new("a", DataType::Int32, false),
   Field::new("b", DataType::Int32, false),
   Field::new("c", DataType::Int32, false),
]);

// reference to column b is index 1
let column_b = Column::new_with_schema("b", &schema).unwrap();
assert_eq!(column_b.index(), 1);

// reference to column c is index 2
let column_c = Column::new_with_schema("c", &schema).unwrap();
assert_eq!(column_c.index(), 2);

Implementations

impl Column

pub fn new(name: &str, index: usize) -> Column

Create a new column expression which references the column with the given index in the schema.

pub fn new_with_schema( name: &str, schema: &Schema, ) -> Result<Column, DataFusionError>

Create a new column expression which references the column with the given name in the schema

pub fn name(&self) -> &str

Get the column’s name

pub fn index(&self) -> usize

Get the column’s schema index

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 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 PartialEq<dyn Any> for Column

fn eq(&self, other: &(dyn Any + 'static)) -> 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 PartialEq for Column

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

fn as_any(&self) -> &(dyn Any + 'static)

Return a reference to Any that can be used for downcasting

fn data_type(&self, input_schema: &Schema) -> Result<DataType, DataFusionError>

Get the data type of this expression, given the schema of the input

fn nullable(&self, input_schema: &Schema) -> Result<bool, DataFusionError>

Decide whether this expression is nullable, given the schema of the input

fn evaluate( &self, batch: &RecordBatch, ) -> Result<ColumnarValue, DataFusionError>

Evaluate the expression

fn children(&self) -> Vec<&Arc<dyn PhysicalExpr>>

Get a list of child PhysicalExpr that provide the input for this expr.

fn with_new_children( self: Arc<Column>, _children: Vec<Arc<dyn PhysicalExpr>>, ) -> Result<Arc<dyn PhysicalExpr>, DataFusionError>

Returns a new PhysicalExpr where all children were replaced by new exprs.

fn dyn_hash(&self, state: &mut dyn Hasher)

Update the hash state with this expression requirements from Hash.

fn evaluate_selection( &self, batch: &RecordBatch, selection: &BooleanArray, ) -> Result<ColumnarValue, DataFusionError>

Evaluate an expression against a RecordBatch after first applying a validity array

fn evaluate_bounds( &self, _children: &[&Interval], ) -> Result<Interval, DataFusionError>

Computes the output interval for the expression, given the input intervals.

fn propagate_constraints( &self, _interval: &Interval, _children: &[&Interval], ) -> Result<Option<Vec<Interval>>, DataFusionError>

Updates bounds for child expressions, given a known interval for this expression.

fn get_properties( &self, _children: &[ExprProperties], ) -> Result<ExprProperties, DataFusionError>

Calculates the properties of this PhysicalExpr based on its children’s properties (i.e. order and range), recursively aggregating the information from its children. In cases where the PhysicalExpr has no children (e.g., Literal or Column), these properties should be specified externally, as the function defaults to unknown properties.

impl Eq for Column

impl StructuralPartialEq for Column