Enum Predicate 

pub enum Predicate {
    BooleanExpression(Expression),
    Not(Box<Predicate>),
    Unary(UnaryPredicate),
    Binary(BinaryPredicate),
    Junction(JunctionPredicate),
    Opaque(OpaquePredicate),
    Unknown(String),
}

A SQL predicate.

These predicates do not track or validate data types, other than the type of literals. It is up to the predicate evaluator to validate the predicate against a schema and add appropriate casts as required.

Variants

BooleanExpression(Expression)

A boolean-valued expression, useful for e.g. AND(<boolean_col1>, <boolean_col2>).

Not(Box<Predicate>)

Boolean inversion (true <-> false)

NOTE: NOT is not a normal unary predicate, because it requires a predicate as input (not an expression), and is never directly evaluated. Instead, observing that all predicates are invertible, NOT is always pushed down into its child predicate, inverting it. For example, NOT (a < b) pushes down and inverts < to >=, producing a >= b.

Unary(UnaryPredicate)

A unary operation.

Binary(BinaryPredicate)

A binary operation.

Junction(JunctionPredicate)

A junction operation (AND/OR).

Opaque(OpaquePredicate)

A predicate that the engine defines and implements. Kernel interacts with the predicate only through methods provided by the OpaquePredicateOp trait.

Unknown(String)

An unknown predicate (i.e. one that neither kernel nor engine attempts to evaluate). For data skipping purposes, kernel treats unknown predicates as if they were literal NULL values (which may disable skipping if it “poisons” the predicate), but engines MUST NOT attempt to interpret them as NULL when evaluating query filters because it could produce incorrect results. For example, converting WHERE <fancy-udf-invocation> to WHERE NULL is equivalent to WHERE FALSE and would filter out all rows – almost certainly NOT what the query author intended. Use Predicate::Opaque for predicates kernel doesn’t understand but which engine can still evaluate.

Implementations

impl Predicate

pub fn references(&self) -> HashSet<&ColumnName>

Returns a set of columns referenced by this predicate.

pub fn column<A>(field_names: impl IntoIterator<Item = A>) -> Predicate

where ColumnName: FromIterator<A>,

Creates a new boolean column reference. See also Expression::column.

pub const fn literal(value: bool) -> Self

Create a new literal boolean value

pub const fn null_literal() -> Self

Creates a NULL literal boolean value

pub fn from_expr(expr: impl Into<Expression>) -> Self

Converts a boolean-valued expression into a predicate

pub fn not(pred: impl Into<Self>) -> Self

Logical NOT (boolean inversion)

pub fn is_null(expr: impl Into<Expression>) -> Predicate

Create a new predicate self IS NULL

pub fn is_not_null(expr: impl Into<Expression>) -> Predicate

Create a new predicate self IS NOT NULL

pub fn eq(a: impl Into<Expression>, b: impl Into<Expression>) -> Self

Create a new predicate self == other

pub fn ne(a: impl Into<Expression>, b: impl Into<Expression>) -> Self

Create a new predicate self != other

pub fn le(a: impl Into<Expression>, b: impl Into<Expression>) -> Self

Create a new predicate self <= other

pub fn lt(a: impl Into<Expression>, b: impl Into<Expression>) -> Self

Create a new predicate self < other

pub fn ge(a: impl Into<Expression>, b: impl Into<Expression>) -> Self

Create a new predicate self >= other

pub fn gt(a: impl Into<Expression>, b: impl Into<Expression>) -> Self

Create a new predicate self > other

pub fn distinct(a: impl Into<Expression>, b: impl Into<Expression>) -> Self

Create a new predicate DISTINCT(self, other)

pub fn and(a: impl Into<Self>, b: impl Into<Self>) -> Self

Create a new predicate self AND other

pub fn or(a: impl Into<Self>, b: impl Into<Self>) -> Self

Create a new predicate self OR other

pub fn and_from(preds: impl IntoIterator<Item = Self>) -> Self

Creates a new predicate AND(preds…). See Self::junction for normalization of empty and single-element inputs.

pub fn or_from(preds: impl IntoIterator<Item = Self>) -> Self

Creates a new predicate OR(preds…). See Self::junction for normalization of empty and single-element inputs.

pub fn unary(op: UnaryPredicateOp, expr: impl Into<Expression>) -> Self

Creates a new unary predicate OP expr

pub fn binary( op: BinaryPredicateOp, lhs: impl Into<Expression>, rhs: impl Into<Expression>, ) -> Self

Creates a new binary predicate lhs OP rhs

pub fn junction( op: JunctionPredicateOp, preds: impl IntoIterator<Item = Self>, ) -> Self

Creates a new junction predicate OP(preds…). Normalizes degenerate cases:

• Empty junction returns the identity element (the value that has no effect when combined with other predicates under the same operator):
  • AND() -> true, because true AND p == p for any predicate p.
  • OR() -> false, because false OR p == p for any predicate p.
• Single-element junction unwraps the element: AND(p) / OR(p) -> p.

pub fn opaque( op: impl OpaquePredicateOp, exprs: impl IntoIterator<Item = Expression>, ) -> Self

Creates a new opaque predicate

pub fn unknown(name: impl Into<String>) -> Self

Creates a new unknown predicate

Trait Implementations

impl ArrowOpaquePredicate for Predicate

Available on crate feature arrow-expression and crate feature default-engine-base and (crate features default-engine-native-tls or default-engine-rustls or arrow-conversion) only.

fn arrow_opaque<T: ArrowOpaquePredicateOp>( op: T, exprs: impl IntoIterator<Item = Expression>, ) -> Predicate

Creates a new opaque predicate. See also Predicate::opaque.

impl Clone for Predicate

fn clone(&self) -> Predicate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Predicate

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Predicate

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Predicate

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

Formats the value using the given formatter.

impl From<ColumnName> for Predicate

fn from(value: ColumnName) -> Self

Converts to this type from the input type.

impl From<Predicate> for Expression

fn from(value: Predicate) -> Self

Converts to this type from the input type.

impl PartialEq for Predicate

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Predicate