Struct NOW_EXPR

struct NOW_EXPR {
    __private_field: (),
}

The [Expr] to call UDF function now().

Fields

__private_field: ()

Methods from Deref<Target = Expr>

pub fn display_name(&self) -> Result<String, DataFusionError>

👎Deprecated since 40.0.0: use schema_name instead

pub fn schema_name(&self) -> impl Display

The name of the column (field) that this Expr will produce.

For example, for a projection (e.g. SELECT <expr>) the resulting arrow Schema will have a field with this name.

Note that the resulting string is subtlety different from the Display representation for certain Expr. Some differences:

1. [Expr::Alias], which shows only the alias itself
2. [Expr::Cast] / [Expr::TryCast], which only displays the expression

Example

let expr = col("foo").eq(lit(42));
assert_eq!("foo = Int32(42)", expr.schema_name().to_string());

let expr = col("foo").alias("bar").eq(lit(11));
assert_eq!("bar = Int32(11)", expr.schema_name().to_string());

pub fn qualified_name(&self) -> (Option<TableReference>, String)

Returns the qualifier and the schema name of this expression.

Used when the expression forms the output field of a certain plan. The result is the field’s qualifier and field name in the plan’s output schema. We can use this qualified name to reference the field.

pub fn canonical_name(&self) -> String

👎Deprecated since 42.0.0: use format! instead

Returns a full and complete string representation of this expression.

pub fn variant_name(&self) -> &str

Return String representation of the variant represented by self Useful for non-rust based bindings

pub fn name_for_alias(&self) -> Result<String, DataFusionError>

Return the name to use for the specific Expr

pub fn try_into_col(&self) -> Result<Column, DataFusionError>

👎Deprecated since 39.0.0: use try_as_col instead

pub fn try_as_col(&self) -> Option<&Column>

Return a reference to the inner Column if any

returns None if the expression is not a Column

Note: None may be returned for expressions that are not Column but are convertible to Column such as Cast expressions.

Example

use datafusion_expr::{col, Expr};
let expr = col("foo");
assert_eq!(expr.try_as_col(), Some(&Column::from("foo")));

let expr = col("foo").alias("bar");
assert_eq!(expr.try_as_col(), None);

pub fn get_as_join_column(&self) -> Option<&Column>

Returns the inner Column if any. This is a specialized version of [Self::try_as_col] that take Cast expressions into account when the expression is as on condition for joins.

Called this method when you are sure that the expression is a Column or a Cast expression that wraps a Column.

pub fn to_columns(&self) -> Result<HashSet<Column>, DataFusionError>

👎Deprecated since 40.0.0: use Expr::column_refs instead

Return all referenced columns of this expression.

pub fn column_refs(&self) -> HashSet<&Column>

Return all references to columns in this expression.

Example

// For an expression `a + (b * a)`
let expr = col("a") + (col("b") * col("a"));
let refs = expr.column_refs();
// refs contains "a" and "b"
assert_eq!(refs.len(), 2);
assert!(refs.contains(&Column::new_unqualified("a")));
assert!(refs.contains(&Column::new_unqualified("b")));

pub fn add_column_refs<'a>(&'a self, set: &mut HashSet<&'a Column>)

Adds references to all columns in this expression to the set

See [Self::column_refs] for details

pub fn column_refs_counts(&self) -> HashMap<&Column, usize>

Return all references to columns and their occurrence counts in the expression.

Example

// For an expression `a + (b * a)`
let expr = col("a") + (col("b") * col("a"));
let mut refs = expr.column_refs_counts();
// refs contains "a" and "b"
assert_eq!(refs.len(), 2);
assert_eq!(*refs.get(&Column::new_unqualified("a")).unwrap(), 2);
assert_eq!(*refs.get(&Column::new_unqualified("b")).unwrap(), 1);

pub fn add_column_ref_counts<'a>(&'a self, map: &mut HashMap<&'a Column, usize>)

Adds references to all columns and their occurrence counts in the expression to the map.

See [Self::column_refs_counts] for details

pub fn any_column_refs(&self) -> bool

Returns true if there are any column references in this Expr

pub fn contains_outer(&self) -> bool

Return true if the expression contains out reference(correlated) expressions.

pub fn is_volatile_node(&self) -> bool

Returns true if the expression node is volatile, i.e. whether it can return different results when evaluated multiple times with the same input. Note: unlike [Self::is_volatile], this function does not consider inputs:

• rand() returns true,
• a + rand() returns false

pub fn is_volatile(&self) -> bool

Returns true if the expression is volatile, i.e. whether it can return different results when evaluated multiple times with the same input.

For example the function call RANDOM() is volatile as each call will return a different value.

See [Volatility] for more information.

pub fn short_circuits(&self) -> bool

Returns true if some of this exprs subexpressions may not be evaluated and thus any side effects (like divide by zero) may not be encountered

Trait Implementations

impl Deref for NOW_EXPR

type Target = Expr

The resulting type after dereferencing.

fn deref(&self) -> &Expr

Dereferences the value.

impl LazyStatic for NOW_EXPR