Enum Expression 

pub enum Expression {
    Term(Term),
    Variable(Variable),
    And(Box<Expression>, Box<Expression>),
    Or(Box<Expression>, Box<Expression>),
    Not(Box<Expression>),
    Equal(Box<Expression>, Box<Expression>),
    NotEqual(Box<Expression>, Box<Expression>),
    Less(Box<Expression>, Box<Expression>),
    LessOrEqual(Box<Expression>, Box<Expression>),
    Greater(Box<Expression>, Box<Expression>),
    GreaterOrEqual(Box<Expression>, Box<Expression>),
    Add(Box<Expression>, Box<Expression>),
    Subtract(Box<Expression>, Box<Expression>),
    Multiply(Box<Expression>, Box<Expression>),
    Divide(Box<Expression>, Box<Expression>),
    UnaryPlus(Box<Expression>),
    UnaryMinus(Box<Expression>),
    In(Box<Expression>, Vec<Expression>),
    NotIn(Box<Expression>, Vec<Expression>),
    Exists(Box<GraphPattern>),
    NotExists(Box<GraphPattern>),
    FunctionCall(Function, Vec<Expression>),
    Bound(Variable),
    If(Box<Expression>, Box<Expression>, Box<Expression>),
    Coalesce(Vec<Expression>),
    Literal(Literal),
    IsIri(Box<Expression>),
    IsBlank(Box<Expression>),
    IsLiteral(Box<Expression>),
    IsNumeric(Box<Expression>),
    Str(Box<Expression>),
    Regex(Box<Expression>, Box<Expression>, Option<Box<Expression>>),
}

A SPARQL expression

Variants

Term(Term)

A constant term

Variable(Variable)

A variable

And(Box<Expression>, Box<Expression>)

Logical AND

Or(Box<Expression>, Box<Expression>)

Logical OR

Not(Box<Expression>)

Logical NOT

Equal(Box<Expression>, Box<Expression>)

Equality: =

NotEqual(Box<Expression>, Box<Expression>)

Inequality: !=

Less(Box<Expression>, Box<Expression>)

Less than: <

LessOrEqual(Box<Expression>, Box<Expression>)

Less than or equal: <=

Greater(Box<Expression>, Box<Expression>)

Greater than: >

GreaterOrEqual(Box<Expression>, Box<Expression>)

Greater than or equal: >=

Add(Box<Expression>, Box<Expression>)

Addition: +

Subtract(Box<Expression>, Box<Expression>)

Subtraction: -

Multiply(Box<Expression>, Box<Expression>)

Multiplication: *

Divide(Box<Expression>, Box<Expression>)

Division: /

UnaryPlus(Box<Expression>)

Unary plus: +expr

UnaryMinus(Box<Expression>)

Unary minus: -expr

In(Box<Expression>, Vec<Expression>)

IN expression

NotIn(Box<Expression>, Vec<Expression>)

NOT IN expression

Exists(Box<GraphPattern>)

EXISTS pattern

NotExists(Box<GraphPattern>)

NOT EXISTS pattern

FunctionCall(Function, Vec<Expression>)

Function call

Bound(Variable)

Bound variable test

If(Box<Expression>, Box<Expression>, Box<Expression>)

IF expression

Coalesce(Vec<Expression>)

COALESCE expression

Literal(Literal)

Literal value

IsIri(Box<Expression>)

Test if term is IRI

IsBlank(Box<Expression>)

Test if term is blank node

IsLiteral(Box<Expression>)

Test if term is literal

IsNumeric(Box<Expression>)

Test if term is numeric

Str(Box<Expression>)

String value of term

Regex(Box<Expression>, Box<Expression>, Option<Box<Expression>>)

Regular expression matching

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expression

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Expression

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

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 Expression