Enum Predicate

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

Unbound predicate expression before binding to a schema.

Variants

AlwaysTrue

AlwaysTrue predicate, for example, TRUE.

AlwaysFalse

AlwaysFalse predicate, for example, FALSE.

And(LogicalExpression<Predicate, 2>)

And predicate, for example, a > 10 AND b < 20.

Or(LogicalExpression<Predicate, 2>)

Or predicate, for example, a > 10 OR b < 20.

Not(LogicalExpression<Predicate, 1>)

Not predicate, for example, NOT (a > 10).

Unary(UnaryExpression<Reference>)

Unary expression, for example, a IS NULL.

Binary(BinaryExpression<Reference>)

Binary expression, for example, a > 10.

Set(SetExpression<Reference>)

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

Implementations

impl Predicate

pub fn and(self, other: Predicate) -> Predicate

Combines two predicates with AND.

Example

use std::ops::Bound::Unbounded;

use iceberg::expr::BoundPredicate::Unary;
use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr1 = Reference::new("a").less_than(Datum::long(10));

let expr2 = Reference::new("b").less_than(Datum::long(20));

let expr = expr1.and(expr2);

assert_eq!(&format!("{expr}"), "(a < 10) AND (b < 20)");

pub fn or(self, other: Predicate) -> Predicate

Combines two predicates with OR.

Example

use std::ops::Bound::Unbounded;

use iceberg::expr::BoundPredicate::Unary;
use iceberg::expr::Reference;
use iceberg::spec::Datum;
let expr1 = Reference::new("a").less_than(Datum::long(10));

let expr2 = Reference::new("b").less_than(Datum::long(20));

let expr = expr1.or(expr2);

assert_eq!(&format!("{expr}"), "(a < 10) OR (b < 20)");

pub fn negate(self) -> Predicate

Returns a predicate representing the negation (‘NOT’) of this one, by using inverse predicates rather than wrapping in a NOT. Used for NOT elimination.

Example

use std::ops::Bound::Unbounded;

use iceberg::expr::BoundPredicate::Unary;
use iceberg::expr::{LogicalExpression, Predicate, Reference};
use iceberg::spec::Datum;
let expr1 = Reference::new("a").less_than(Datum::long(10));
let expr2 = Reference::new("b")
    .less_than(Datum::long(5))
    .and(Reference::new("c").less_than(Datum::long(10)));

let result = expr1.negate();
assert_eq!(&format!("{result}"), "a >= 10");

let result = expr2.negate();
assert_eq!(&format!("{result}"), "(b >= 5) OR (c >= 10)");

pub fn rewrite_not(self) -> Predicate

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::{LogicalExpression, Predicate, Reference};
use iceberg::spec::Datum;

let expression = Reference::new("a").less_than(Datum::long(5)).not();
let result = expression.rewrite_not();

assert_eq!(&format!("{result}"), "a >= 5");

Trait Implementations

impl Bind for Predicate

type Bound = BoundPredicate

The type of the bound result.

fn bind( &self, schema: SchemaRef, case_sensitive: bool, ) -> Result<BoundPredicate>

Bind an expression to a schema.

impl Clone for Predicate

fn clone(&self) -> Predicate

Returns a copy 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 Not for Predicate

fn not(self) -> Self::Output

Create a predicate which is the reverse of this predicate. For example: NOT (a > 10).

This is different from Predicate::negate() since it doesn’t rewrite expression, but just adds a NOT operator.

Example

 use std::ops::Bound::Unbounded;

 use iceberg::expr::BoundPredicate::Unary;
 use iceberg::expr::Reference;
 use iceberg::spec::Datum;
 let expr1 = Reference::new("a").less_than(Datum::long(10));

 let expr = !expr1;

 assert_eq!(&format!("{expr}"), "NOT (a < 10)");

type Output = Predicate

The resulting type after applying the ! operator.

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