Enum BoundPredicate

pub enum BoundPredicate {
    AlwaysTrue,
    AlwaysFalse,
    And(LogicalExpression<BoundPredicate, 2>),
    Or(LogicalExpression<BoundPredicate, 2>),
    Not(LogicalExpression<BoundPredicate, 1>),
    Unary(UnaryExpression<BoundReference>),
    Binary(BinaryExpression<BoundReference>),
    Set(SetExpression<BoundReference>),
}

Bound predicate expression after binding to a schema.

Variants

AlwaysTrue

An expression always evaluates to true.

AlwaysFalse

An expression always evaluates to false.

And(LogicalExpression<BoundPredicate, 2>)

An expression combined by AND, for example, a > 10 AND b < 20.

Or(LogicalExpression<BoundPredicate, 2>)

An expression combined by OR, for example, a > 10 OR b < 20.

Not(LogicalExpression<BoundPredicate, 1>)

An expression combined by NOT, for example, NOT (a > 10).

Unary(UnaryExpression<BoundReference>)

Unary expression, for example, a IS NULL.

Binary(BinaryExpression<BoundReference>)

Binary expression, for example, a > 10.

Set(SetExpression<BoundReference>)

Set predicates, for example, a IN (1, 2, 3).

Implementations

impl BoundPredicate

pub fn rewrite_not(self) -> BoundPredicate

Simplifies the expression by removing NOT predicates, directly negating the inner expressions instead. The transformation applies logical laws (such as De Morgan’s laws) to recursively negate and simplify inner expressions within NOT predicates.

Example

use std::ops::Not;

use iceberg::expr::{Bind, BoundPredicate, Reference};
use iceberg::spec::Datum;

// This would need to be bound first, but the concept is:
// let expression = bound_predicate.not();
// let result = expression.rewrite_not();

Trait Implementations

impl Clone for BoundPredicate

fn clone(&self) -> BoundPredicate

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BoundPredicate

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BoundPredicate

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for BoundPredicate

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

Formats the value using the given formatter.

impl PartialEq for BoundPredicate

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

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 BoundPredicate