Enum NodeExpression 

pub enum NodeExpression {
    FocusNode,
    Constant(NodeTerm),
    Path(PropertyPath),
    FilterShape {
        nodes: Box<NodeExpression>,
        shape: String,
    },
    Intersection(Vec<NodeExpression>),
    Union(Vec<NodeExpression>),
    Minus {
        base: Box<NodeExpression>,
        excluded: Box<NodeExpression>,
    },
    IfThenElse {
        condition: Box<NodeExpression>,
        then_expr: Box<NodeExpression>,
        else_expr: Box<NodeExpression>,
    },
    FunctionCall {
        function: String,
        args: Vec<NodeExpression>,
    },
    Count(Box<NodeExpression>),
    Distinct(Box<NodeExpression>),
    OrderBy {
        expr: Box<NodeExpression>,
        sort_path: PropertyPath,
        ascending: bool,
    },
    Limit {
        expr: Box<NodeExpression>,
        limit: usize,
    },
    Offset {
        expr: Box<NodeExpression>,
        offset: usize,
    },
    GroupConcat {
        expr: Box<NodeExpression>,
        separator: String,
    },
}

A SHACL node expression that can be evaluated against a focus node and graph.

Variants

FocusNode

The current focus node itself (sh:this).

Constant(NodeTerm)

A constant term.

Path(PropertyPath)

Follow a property path from the focus node.

FilterShape

Filter nodes through a shape.

Fields

nodes: Box<NodeExpression>

The set of candidate nodes.

shape: String

The shape IRI to filter against.

Intersection(Vec<NodeExpression>)

Intersection of multiple node sets.

Union(Vec<NodeExpression>)

Union of multiple node sets.

Minus

Set difference: nodes in base but not in excluded.

Fields

base: Box<NodeExpression>

Base node set.

excluded: Box<NodeExpression>

Nodes to exclude.

IfThenElse

Conditional: if condition evaluates to non-empty, use then_expr, otherwise use else_expr.

Fields

condition: Box<NodeExpression>

Condition expression.

then_expr: Box<NodeExpression>

Expression when condition is true.

else_expr: Box<NodeExpression>

Expression when condition is false.

FunctionCall

Apply a function to arguments.

Fields

function: String

Function IRI.

args: Vec<NodeExpression>

Argument expressions.

Count(Box<NodeExpression>)

Count the number of nodes from the inner expression.

Distinct(Box<NodeExpression>)

Deduplicate results from the inner expression.

OrderBy

Sort results by a property path.

Fields

expr: Box<NodeExpression>

Expression to sort.

sort_path: PropertyPath

Property path to sort by.

ascending: bool

Ascending order.

Limit

Limit the number of results.

Fields

expr: Box<NodeExpression>

Expression to limit.

limit: usize

Maximum number of results.

Offset

Skip the first N results.

Fields

expr: Box<NodeExpression>

Expression to offset.

offset: usize

Number of results to skip.

GroupConcat

Group-concat: join string values with a separator.

Fields

expr: Box<NodeExpression>

Expression producing the values.

separator: String

Separator string.

Trait Implementations

impl Clone for NodeExpression

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 NodeExpression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NodeExpression

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NodeExpression

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for NodeExpression

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 NodeExpression