Struct datafusion_optimizer::simplify_expressions::expr_simplifier::ExprSimplifier

pub struct ExprSimplifier<S> { /* private fields */ }

This structure handles API for expression simplification

Implementations

impl<S: SimplifyInfo> ExprSimplifier<S>

pub fn new(info: S) -> Self

Create a new ExprSimplifier with the given info such as an instance of [SimplifyContext]. See simplify for an example.

pub fn simplify(&self, expr: Expr) -> Result<Expr>

Simplifies this Expr`s as much as possible, evaluating constants and applying algebraic simplifications.

The types of the expression must match what operators expect, or else an error may occur trying to evaluate. See coerce for a function to help.

Example:

b > 2 AND b > 2

can be written to

b > 2

use datafusion_expr::{col, lit, Expr};
use datafusion_common::Result;
use datafusion_physical_expr::execution_props::ExecutionProps;
use datafusion_optimizer::simplify_expressions::{ExprSimplifier, SimplifyInfo};

/// Simple implementation that provides `Simplifier` the information it needs
/// See SimplifyContext for a structure that does this.
#[derive(Default)]
struct Info {
  execution_props: ExecutionProps,
};

impl SimplifyInfo for Info {
  fn is_boolean_type(&self, expr: &Expr) -> Result<bool> {
    Ok(false)
  }
  fn nullable(&self, expr: &Expr) -> Result<bool> {
    Ok(true)
  }
  fn execution_props(&self) -> &ExecutionProps {
    &self.execution_props
  }
}

// Create the simplifier
let simplifier = ExprSimplifier::new(Info::default());

// b < 2
let b_lt_2 = col("b").gt(lit(2));

// (b < 2) OR (b < 2)
let expr = b_lt_2.clone().or(b_lt_2.clone());

// (b < 2) OR (b < 2) --> (b < 2)
let expr = simplifier.simplify(expr).unwrap();
assert_eq!(expr, b_lt_2);

pub fn coerce(&self, expr: Expr, schema: DFSchemaRef) -> Result<Expr>

Apply type coercion to an Expr so that it can be evaluated as a PhysicalExpr.

See the type coercion module documentation for more details on type coercion