Enum GraphPattern

pub enum GraphPattern {
    QuadPattern {
        subject: GroundTermPattern,
        predicate: NamedNodePattern,
        object: GroundTermPattern,
        graph_name: Option<NamedNodePattern>,
    },
    Path {
        subject: GroundTermPattern,
        path: PropertyPathExpression,
        object: GroundTermPattern,
        graph_name: Option<NamedNodePattern>,
    },
    Join {
        left: Box<Self>,
        right: Box<Self>,
        algorithm: JoinAlgorithm,
    },
    LeftJoin {
        left: Box<Self>,
        right: Box<Self>,
        expression: Expression,
        algorithm: LeftJoinAlgorithm,
    },
    Lateral {
        left: Box<Self>,
        right: Box<Self>,
    },
    Filter {
        expression: Expression,
        inner: Box<Self>,
    },
    Union {
        inner: Vec<Self>,
    },
    Extend {
        inner: Box<Self>,
        variable: Variable,
        expression: Expression,
    },
    Minus {
        left: Box<Self>,
        right: Box<Self>,
        algorithm: MinusAlgorithm,
    },
    Values {
        variables: Vec<Variable>,
        bindings: Vec<Vec<Option<GroundTerm>>>,
    },
    OrderBy {
        inner: Box<Self>,
        expression: Vec<OrderExpression>,
    },
    Project {
        inner: Box<Self>,
        variables: Vec<Variable>,
    },
    Distinct {
        inner: Box<Self>,
    },
    Reduced {
        inner: Box<Self>,
    },
    Slice {
        inner: Box<Self>,
        start: usize,
        length: Option<usize>,
    },
    Group {
        inner: Box<Self>,
        variables: Vec<Variable>,
        aggregates: Vec<(Variable, AggregateExpression)>,
    },
    Service {
        name: NamedNodePattern,
        inner: Box<Self>,
        silent: bool,
    },
}

A SPARQL query graph pattern.

Variants

QuadPattern

A basic graph pattern.

Fields

subject: GroundTermPattern

predicate: NamedNodePattern

object: GroundTermPattern

graph_name: Option<NamedNodePattern>

Path

A property path pattern.

Fields

subject: GroundTermPattern

path: PropertyPathExpression

object: GroundTermPattern

graph_name: Option<NamedNodePattern>

Join

Join.

Fields

left: Box<Self>

right: Box<Self>

algorithm: JoinAlgorithm

LeftJoin

LeftJoin.

Fields

left: Box<Self>

right: Box<Self>

expression: Expression

algorithm: LeftJoinAlgorithm

Lateral

Lateral join i.e. evaluate right for all result row of left

Fields

left: Box<Self>

right: Box<Self>

Filter

Filter.

Fields

expression: Expression

inner: Box<Self>

Union

Union.

Fields

inner: Vec<Self>

Extend

Extend.

Fields

inner: Box<Self>

variable: Variable

expression: Expression

Minus

Minus.

Fields

left: Box<Self>

right: Box<Self>

algorithm: MinusAlgorithm

Values

A table used to provide inline values

Fields

variables: Vec<Variable>

bindings: Vec<Vec<Option<GroundTerm>>>

OrderBy

OrderBy.

Fields

inner: Box<Self>

expression: Vec<OrderExpression>

Project

Project.

Fields

inner: Box<Self>

variables: Vec<Variable>

Distinct

Distinct.

Fields

inner: Box<Self>

Reduced

Reduced.

Fields

inner: Box<Self>

Slice

Slice.

Fields

inner: Box<Self>

start: usize

length: Option<usize>

Group

Group.

Fields

inner: Box<Self>

variables: Vec<Variable>

aggregates: Vec<(Variable, AggregateExpression)>

Service

Service.

Fields

name: NamedNodePattern

inner: Box<Self>

silent: bool

Implementations

impl GraphPattern

pub fn empty() -> Self

pub fn empty_singleton() -> Self

pub fn is_empty_singleton(&self) -> bool

pub fn join(left: Self, right: Self, algorithm: JoinAlgorithm) -> Self

pub fn lateral(left: Self, right: Self) -> Self

pub fn left_join( left: Self, right: Self, expression: Expression, algorithm: LeftJoinAlgorithm, ) -> Self

pub fn minus(left: Self, right: Self, algorithm: MinusAlgorithm) -> Self

pub fn union(left: Self, right: Self) -> Self

pub fn union_all(args: impl IntoIterator<Item = Self>) -> Self

pub fn filter(inner: Self, expression: Expression) -> Self

pub fn extend(inner: Self, variable: Variable, expression: Expression) -> Self

pub fn values( variables: Vec<Variable>, bindings: Vec<Vec<Option<GroundTerm>>>, ) -> Self

pub fn order_by(inner: Self, expression: Vec<OrderExpression>) -> Self

pub fn project(inner: Self, variables: Vec<Variable>) -> Self

pub fn distinct(inner: Self) -> Self

pub fn reduced(inner: Self) -> Self

pub fn slice(inner: Self, start: usize, length: Option<usize>) -> Self

pub fn group( inner: Self, variables: Vec<Variable>, aggregates: Vec<(Variable, AggregateExpression)>, ) -> Self

pub fn service(inner: Self, name: NamedNodePattern, silent: bool) -> Self

pub fn lookup_used_variables<'a>( &'a self, callback: &mut impl FnMut(&'a Variable), )

Trait Implementations

impl Clone for GraphPattern

fn clone(&self) -> GraphPattern

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GraphPattern

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

Formats the value using the given formatter.

impl From<&GraphPattern> for GraphPattern

fn from(pattern: &AlGraphPattern) -> Self

Converts to this type from the input type.

impl From<&GraphPattern> for GraphPattern

fn from(pattern: &GraphPattern) -> Self

Converts to this type from the input type.

impl Hash for GraphPattern

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for GraphPattern

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

impl StructuralPartialEq for GraphPattern