Enum qrlew::expr::Expr

pub enum Expr {
    Column(Column),
    Value(Value),
    Function(Function),
    Aggregate(Aggregate),
    Struct(Struct),
}

A Expr enum inspired by: https://docs.rs/sqlparser/latest/sqlparser/ast/enum.Expr.html and mostly: https://docs.rs/polars/latest/polars/prelude/enum.Expr.html or https://docs.rs/polars-lazy/latest/polars_lazy/dsl/enum.Expr.html

Variants

Column(Column)

Value(Value)

Function(Function)

Aggregate(Aggregate)

Struct(Struct)

Implementations

impl Expr

pub fn dot<W: Write>( &self, data_type: DataType, w: &mut W, opts: &[&str] ) -> Result<()>

Render the Expr to dot

pub fn dot_value<W: Write>( &self, val: Value, w: &mut W, opts: &[&str] ) -> Result<()>

Render the Expr to dot

impl Expr

pub fn gaussian_noise() -> Self

Gaussian noise based on Box Muller transform

pub fn add_gaussian_noise(self, sigma: f64) -> Self

Gaussian noise based on Box Muller transform

impl Expr

pub fn reduce_modulo_bijection(&self) -> &Expr

Reduce the expression modulo a bijection

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

Some column if it reduces to a column, None else.

pub fn is_unique(&self) -> bool

True if reduces into a unique 0-ary function.

pub fn eq_modulo_bijection(&self, expr: &Expr) -> bool

True if 2 expressions are equal modulo a bijection

impl Expr

Implement random expression constructor (same thing but no macro here)

pub fn random(n: usize) -> Expr

pub fn filter_column( name: &str, min: Option<Value>, max: Option<Value>, possible_values: Vec<Value> ) -> Option<Expr>

pub fn and_iter<I: IntoIterator<Item = Expr>>(exprs: I) -> Expr

pub fn filter( columns: BTreeMap<&str, (Option<Value>, Option<Value>, Vec<Value>)> ) -> Expr

Returns an Expr for filtering the columns

Arguments

• columns: Vec<(column_name, minimal_value, maximal_value, possible_values)>

For example,

• filter(vec![("my_col", Value::float(2.), Value::float(10.), vec![])]) ≡ (my_col > 2.) and (my_col < 10)
• filter(vec![("my_col", None, Value::float(10.), vec![Value::integer(1), Value::integer(2), Value::integer(5)])]) ≡ (my_col < 10.) and (my_col in (1, 2, 5))
• filter(vec![("my_col1", None, Value::integer(10), vec![]), ("my_col2", Value::float(1.), None, vec![])])]) ≡ (my_col1 < 10) and (my_col2 > 1.)

impl Expr

pub fn pi() -> Expr

pub fn newid() -> Expr

pub fn current_date() -> Expr

pub fn current_time() -> Expr

pub fn current_timestamp() -> Expr

impl Expr

pub fn opposite<E: Into<Expr>>(expr: E) -> Expr

pub fn not<E: Into<Expr>>(expr: E) -> Expr

pub fn exp<E: Into<Expr>>(expr: E) -> Expr

pub fn ln<E: Into<Expr>>(expr: E) -> Expr

pub fn log<E: Into<Expr>>(expr: E) -> Expr

pub fn abs<E: Into<Expr>>(expr: E) -> Expr

pub fn sin<E: Into<Expr>>(expr: E) -> Expr

pub fn cos<E: Into<Expr>>(expr: E) -> Expr

pub fn sqrt<E: Into<Expr>>(expr: E) -> Expr

pub fn md5<E: Into<Expr>>(expr: E) -> Expr

pub fn lower<E: Into<Expr>>(expr: E) -> Expr

pub fn upper<E: Into<Expr>>(expr: E) -> Expr

pub fn char_length<E: Into<Expr>>(expr: E) -> Expr

pub fn cast_as_text<E: Into<Expr>>(expr: E) -> Expr

pub fn cast_as_integer<E: Into<Expr>>(expr: E) -> Expr

pub fn cast_as_float<E: Into<Expr>>(expr: E) -> Expr

pub fn cast_as_boolean<E: Into<Expr>>(expr: E) -> Expr

pub fn cast_as_date_time<E: Into<Expr>>(expr: E) -> Expr

pub fn cast_as_date<E: Into<Expr>>(expr: E) -> Expr

pub fn cast_as_time<E: Into<Expr>>(expr: E) -> Expr

pub fn ceil<E: Into<Expr>>(expr: E) -> Expr

pub fn floor<E: Into<Expr>>(expr: E) -> Expr

pub fn sign<E: Into<Expr>>(expr: E) -> Expr

pub fn unhex<E: Into<Expr>>(expr: E) -> Expr

pub fn extract_year<E: Into<Expr>>(expr: E) -> Expr

pub fn extract_month<E: Into<Expr>>(expr: E) -> Expr

pub fn extract_day<E: Into<Expr>>(expr: E) -> Expr

pub fn extract_hour<E: Into<Expr>>(expr: E) -> Expr

pub fn extract_minute<E: Into<Expr>>(expr: E) -> Expr

pub fn extract_second<E: Into<Expr>>(expr: E) -> Expr

pub fn extract_microsecond<E: Into<Expr>>(expr: E) -> Expr

pub fn extract_millisecond<E: Into<Expr>>(expr: E) -> Expr

pub fn extract_dow<E: Into<Expr>>(expr: E) -> Expr

pub fn extract_week<E: Into<Expr>>(expr: E) -> Expr

pub fn dayname<E: Into<Expr>>(expr: E) -> Expr

pub fn quarter<E: Into<Expr>>(expr: E) -> Expr

pub fn date<E: Into<Expr>>(expr: E) -> Expr

pub fn unix_timestamp<E: Into<Expr>>(expr: E) -> Expr

pub fn is_null<E: Into<Expr>>(expr: E) -> Expr

impl Expr

pub fn plus<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn minus<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn multiply<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn modulo<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn string_concat<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn gt<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn lt<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn gt_eq<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn lt_eq<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn eq<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn not_eq<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn and<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn or<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn xor<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn bitwise_or<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn bitwise_and<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn bitwise_xor<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn pow<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn position<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn in_list<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn least<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn greatest<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn coalesce<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn rtrim<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn ltrim<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn substr<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn trunc<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn round<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn regexp_contains<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn encode<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn decode<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn date_format<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn from_unixtime<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn like<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn ilike<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn choose<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

pub fn is_bool<L: Into<Expr>, R: Into<Expr>>(left: L, right: R) -> Expr

impl Expr

pub fn divide<L: Into<Expr>, R: Into<Expr> + Clone>(left: L, right: R) -> Expr

impl Expr

pub fn case<F: Into<Expr>, S: Into<Expr>, T: Into<Expr>>( first: F, second: S, third: T ) -> Expr

pub fn substr_with_size<F: Into<Expr>, S: Into<Expr>, T: Into<Expr>>( first: F, second: S, third: T ) -> Expr

pub fn regexp_replace<F: Into<Expr>, S: Into<Expr>, T: Into<Expr>>( first: F, second: S, third: T ) -> Expr

pub fn datetime_diff<F: Into<Expr>, S: Into<Expr>, T: Into<Expr>>( first: F, second: S, third: T ) -> Expr

impl Expr

pub fn regexp_extract<F: Into<Expr>, S: Into<Expr>, T: Into<Expr>, U: Into<Expr>>( first: F, second: S, third: T, fourth: U ) -> Expr

impl Expr

pub fn concat<E: Into<Expr>>(args: Vec<E>) -> Expr

impl Expr

pub fn first<E: Into<Expr>>(expr: E) -> Expr

pub fn last<E: Into<Expr>>(expr: E) -> Expr

pub fn min<E: Into<Expr>>(expr: E) -> Expr

pub fn max<E: Into<Expr>>(expr: E) -> Expr

pub fn count<E: Into<Expr>>(expr: E) -> Expr

pub fn mean<E: Into<Expr>>(expr: E) -> Expr

pub fn sum<E: Into<Expr>>(expr: E) -> Expr

pub fn var<E: Into<Expr>>(expr: E) -> Expr

pub fn std<E: Into<Expr>>(expr: E) -> Expr

pub fn count_distinct<E: Into<Expr>>(expr: E) -> Expr

pub fn mean_distinct<E: Into<Expr>>(expr: E) -> Expr

pub fn sum_distinct<E: Into<Expr>>(expr: E) -> Expr

pub fn var_distinct<E: Into<Expr>>(expr: E) -> Expr

pub fn std_distinct<E: Into<Expr>>(expr: E) -> Expr

impl Expr

Basic constructors They are short because they are supposed to be the primary API for the module

pub fn col<S: Into<String>>(field: S) -> Expr

pub fn qcol<S: Into<String>>(relation: S, field: S) -> Expr

pub fn val<V: Into<Value>>(value: V) -> Expr

pub fn list<L: IntoIterator<Item = V>, V: Into<Value>>(values: L) -> Expr

pub fn structured<S: Clone + Into<String>, E: Clone + Into<Arc<Expr>>, F: AsRef<[(S, E)]>>( fields: F ) -> Expr

pub fn all<F: IntoIterator<Item = Expr>>(factors: F) -> Expr

impl Expr

pub fn columns(&self) -> Vec<&Column>

Collect all columns in an expression

impl Expr

pub fn has_column(&self) -> bool

impl Expr

pub fn rename<'a>(&'a self, columns: &'a Hierarchy<Identifier>) -> Expr

impl Expr

pub fn replace(&self, map: Vec<(Expr, Expr)>) -> (Expr, Vec<(Expr, Expr)>)

Replace matched left expressions by corresponding right expressions

pub fn alias( &self, named_exprs: Vec<(String, Expr)> ) -> (Expr, Vec<(String, Expr)>)

Alias expressions by name

pub fn into_aggregate(self) -> Expr

Transform an expression into an aggregation

Trait Implementations

impl<'a> Acceptor<'a> for Expr

Implement the Acceptor trait

fn dependencies(&'a self) -> Dependencies<'a, Self>

All the sub-objects to visit

fn accept<O: Clone, V: Visitor<'a, Self, O>>(&'a self, visitor: V) -> O

fn iter(&'a self) -> Iter<'a, Self>

fn iter_with<O: Clone, V: Visitor<'a, Self, O>>( &'a self, visitor: V ) -> IterWith<'a, O, Self, V>

impl Add for Expr

type Output = Expr

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl And<Expr> for Map

Propagate expr columns into the Map and return the modified expression

type Product = (Map, Expr)

fn and(self, expr: Expr) -> Self::Product

impl And<Expr> for Reduce

Propagate expr columns into the Reduce and return the modified expression

type Product = (Reduce, Expr)

fn and(self, expr: Expr) -> Self::Product

impl BitAnd for Expr

type Output = Expr

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitOr for Expr

type Output = Expr

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitXor for Expr

type Output = Expr

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Display for Expr

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

Formats the value using the given formatter.

impl Div for Expr

type Output = Expr

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl From<&Expr> for Expr

Based on the FromExprVisitor implement the From trait

fn from(value: &Expr) -> Self

Converts to this type from the input type.

impl From<Aggregate> for Expr

fn from(v: Aggregate) -> Self

Converts to this type from the input type.

impl From<AggregateColumn> for Expr

fn from(value: AggregateColumn) -> Self

Converts to this type from the input type.

impl From<Function> for Expr

fn from(v: Function) -> Self

Converts to this type from the input type.

impl From<Identifier> for Expr

fn from(v: Column) -> Self

Converts to this type from the input type.

impl From<Struct> for Expr

fn from(v: Struct) -> Self

Converts to this type from the input type.

impl From<Value> for Expr

fn from(v: Value) -> Self

Converts to this type from the input type.

impl Function for Expr

fn domain(&self) -> DataType

The domain, given as a Cartesian product

fn super_image(&self, set: &DataType) -> Result<DataType, Error>

A super-image of a set (a set containing the image of the set and included in the co-domain)

fn value(&self, arg: &Value) -> Result<Value, Error>

The actual implementation of the function

fn co_domain(&self) -> DataType

The co-domain

impl Hash for Expr

fn hash<__H: Hasher>(&self, state: &mut __H)

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<'a> IntoIterator for &'a Expr

type Item = &'a Expr

The type of the elements being iterated over.

type IntoIter = FilterMap<Iterator<'a, &'a Expr, Identity, Expr>, fn(_: (&'a Expr, State<&'a Expr>)) -> Option<&'a Expr>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Mul for Expr

type Output = Expr

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl Neg for Expr

type Output = Expr

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for Expr

type Output = Expr

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for Expr

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

type Output = Expr

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl Sub for Expr

type Output = Expr

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<'a> TryFrom<&'a Expr> for Expr

Based on the TryIntoExprVisitor implement the TryFrom trait

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &'a Expr) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Expr> for Aggregate

type Error = Error

The type returned in the event of a conversion error.

fn try_from(expr: Expr) -> Result<Self>

Performs the conversion.

impl TryFrom<Expr> for AggregateColumn

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Expr) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Expr> for Function

type Error = Error

The type returned in the event of a conversion error.

fn try_from(expr: Expr) -> Result<Self>

Performs the conversion.

impl TryFrom<Expr> for Column

type Error = Error

The type returned in the event of a conversion error.

fn try_from(expr: Expr) -> Result<Self>

Performs the conversion.

impl TryFrom<Expr> for Struct

type Error = Error

The type returned in the event of a conversion error.

fn try_from(expr: Expr) -> Result<Self>

Performs the conversion.

impl TryFrom<Expr> for Value

type Error = Error

The type returned in the event of a conversion error.

fn try_from(expr: Expr) -> Result<Self>

Performs the conversion.

impl<'a> TryFrom<WithContext<&'a Expr, &'a Hierarchy<Identifier>>> for Expr

Based on the TryIntoExprVisitor implement the TryFrom trait

type Error = Error

The type returned in the event of a conversion error.

fn try_from( value: WithContext<&'a Expr, &'a Hierarchy<Identifier>> ) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> Visitor<'a, Expr> for RenameVisitor<'a>

fn column(&self, column: &'a Column) -> Expr

fn value(&self, value: &'a Value) -> Expr

fn function(&self, function: &'a Function, arguments: Vec<Expr>) -> Expr

fn aggregate(&self, aggregate: &'a Aggregate, argument: Expr) -> Expr

fn structured(&self, fields: Vec<(Identifier, Expr)>) -> Expr

impl<'a> Visitor<'a, Expr, (Expr, Vec<(Expr, Expr)>)> for ReplaceVisitor

fn visit( &self, acceptor: &'a Expr, dependencies: Visited<'a, Expr, (Expr, Vec<(Expr, Expr)>)> ) -> (Expr, Vec<(Expr, Expr)>)

A function called on each node of a structured object with its dependencies already visited

fn dependencies(&self, acceptor: &'a A) -> Dependencies<'a, A>

Describe the dependencies of the acceptor The dependencies can be customized

impl<RequireInput> With<Expr> for MapBuilder<RequireInput>

fn with(self, expr: Expr) -> Self

impl<RequireInput> With<Expr> for ReduceBuilder<RequireInput>

fn with(self, expr: Expr) -> Self

impl Eq for Expr

impl StructuralPartialEq for Expr

impl Variant for Expr