Enum FilterExpr 

pub enum FilterExpr {
    Eq(ExprTerm, ExprTerm),
    NotEq(ExprTerm, ExprTerm),
    Lt(ExprTerm, ExprTerm),
    LtEq(ExprTerm, ExprTerm),
    Gt(ExprTerm, ExprTerm),
    GtEq(ExprTerm, ExprTerm),
    And(Box<FilterExpr>, Box<FilterExpr>),
    Or(Box<FilterExpr>, Box<FilterExpr>),
    Not(Box<FilterExpr>),
    Bound(Var),
    Regex(ExprTerm, String, Option<String>),
    StartsWith(ExprTerm, String),
    EndsWith(ExprTerm, String),
    Contains(ExprTerm, String),
    IsUri(ExprTerm),
    IsLiteral(ExprTerm),
    IsBlank(ExprTerm),
    In(ExprTerm, Vec<ExprTerm>),
    NotIn(ExprTerm, Vec<ExprTerm>),
    True,
    False,
}

Filter expression for filtering bindings

Variants

Eq(ExprTerm, ExprTerm)

Equality

NotEq(ExprTerm, ExprTerm)

Not equal

Lt(ExprTerm, ExprTerm)

Less than

LtEq(ExprTerm, ExprTerm)

Less than or equal

Gt(ExprTerm, ExprTerm)

Greater than

GtEq(ExprTerm, ExprTerm)

Greater than or equal

And(Box<FilterExpr>, Box<FilterExpr>)

Logical AND

Or(Box<FilterExpr>, Box<FilterExpr>)

Logical OR

Not(Box<FilterExpr>)

Logical NOT

Bound(Var)

Bound check

Regex(ExprTerm, String, Option<String>)

Regex match

StartsWith(ExprTerm, String)

String starts with

EndsWith(ExprTerm, String)

String ends with

Contains(ExprTerm, String)

String contains

IsUri(ExprTerm)

Is IRI

IsLiteral(ExprTerm)

Is literal

IsBlank(ExprTerm)

Is blank node

In(ExprTerm, Vec<ExprTerm>)

In list

NotIn(ExprTerm, Vec<ExprTerm>)

Not in list

True

True constant

False

False constant

Implementations

impl FilterExpr

pub fn and(left: FilterExpr, right: FilterExpr) -> FilterExpr

Create AND expression

pub fn or(left: FilterExpr, right: FilterExpr) -> FilterExpr

Create OR expression

pub fn not(expr: FilterExpr) -> FilterExpr

Create NOT expression

pub fn evaluate(&self, binding: &Binding) -> bool

Evaluate against a binding

Trait Implementations

impl Clone for FilterExpr

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FilterExpr

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

Formats the value using the given formatter.