Struct QuerySolution

pub struct QuerySolution {
    variables: Arc<[Variable]>,
    values: Vec<Option<Term>>,
}

Tuple associating variables and terms that are the result of a SPARQL query.

It is the equivalent of a row in SQL.

use sparesults::QuerySolution;
use oxrdf::{Variable, Literal};

let solution = QuerySolution::from((vec![Variable::new("foo")?, Variable::new("bar")?], vec![Some(Literal::from(1).into()), None]));
assert_eq!(solution.get("foo"), Some(&Literal::from(1).into())); // Get the value of the variable ?foo if it exists (here yes).
assert_eq!(solution.get(1), None); // Get the value of the second column if it exists (here no).

Fields

variables: Arc<[Variable]>

values: Vec<Option<Term>>

Implementations

impl QuerySolution

pub fn get(&self, index: impl VariableSolutionIndex) -> Option<&Term>

Returns a value for a given position in the tuple (usize) or a given variable name (&str, Variable or [VariableRef]).

use sparesults::QuerySolution;
use oxrdf::{Variable, Literal};

let solution = QuerySolution::from((vec![Variable::new("foo")?, Variable::new("bar")?], vec![Some(Literal::from(1).into()), None]));
assert_eq!(solution.get("foo"), Some(&Literal::from(1).into())); // Get the value of the variable ?foo if it exists (here yes).
assert_eq!(solution.get(1), None); // Get the value of the second column if it exists (here no).

pub fn len(&self) -> usize

The number of variables which could be bound.

It is also the number of columns in the solutions table.

use oxrdf::{Literal, Variable};
use sparesults::QuerySolution;

let solution = QuerySolution::from((
    vec![Variable::new("foo")?, Variable::new("bar")?],
    vec![Some(Literal::from(1).into()), None],
));
assert_eq!(solution.len(), 2);

pub fn is_empty(&self) -> bool

Is there any variable bound in the table?

use oxrdf::{Literal, Variable};
use sparesults::QuerySolution;

let solution = QuerySolution::from((
    vec![Variable::new("foo")?, Variable::new("bar")?],
    vec![Some(Literal::from(1).into()), None],
));
assert!(!solution.is_empty());

let empty_solution = QuerySolution::from((
    vec![Variable::new("foo")?, Variable::new("bar")?],
    vec![None, None],
));
assert!(empty_solution.is_empty());

pub fn iter(&self) -> impl Iterator<Item = (&Variable, &Term)>

Returns an iterator over bound variables.

use oxrdf::{Literal, Variable};
use sparesults::QuerySolution;

let solution = QuerySolution::from((
    vec![Variable::new("foo")?, Variable::new("bar")?],
    vec![Some(Literal::from(1).into()), None],
));
assert_eq!(
    solution.iter().collect::<Vec<_>>(),
    vec![(&Variable::new("foo")?, &Literal::from(1).into())]
);

pub fn values(&self) -> &[Option<Term>]

Returns the ordered slice of variable values.

use oxrdf::{Literal, Variable};
use sparesults::QuerySolution;

let solution = QuerySolution::from((
    vec![Variable::new("foo")?, Variable::new("bar")?],
    vec![Some(Literal::from(1).into()), None],
));
assert_eq!(solution.values(), &[Some(Literal::from(1).into()), None]);

pub fn variables(&self) -> &[Variable]

Returns the ordered slice of the solution variables, bound or not.

use oxrdf::{Literal, Variable};
use sparesults::QuerySolution;

let solution = QuerySolution::from((
    vec![Variable::new("foo")?, Variable::new("bar")?],
    vec![Some(Literal::from(1).into()), None],
));
assert_eq!(
    solution.variables(),
    &[Variable::new("foo")?, Variable::new("bar")?]
);

Trait Implementations

impl Debug for QuerySolution

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

Formats the value using the given formatter.

impl<V, S> From<(V, S)> for QuerySolution

where V: Into<Arc<[Variable]>>, S: Into<Vec<Option<Term>>>,

fn from(_: (V, S)) -> QuerySolution

Converts to this type from the input type.

impl Index<&Variable> for QuerySolution

type Output = Term

The returned type after indexing.

fn index( &self, index: &Variable, ) -> &<QuerySolution as Index<&Variable>>::Output

Performs the indexing (container[index]) operation.

impl Index<&str> for QuerySolution

type Output = Term

The returned type after indexing.

fn index(&self, index: &str) -> &<QuerySolution as Index<&str>>::Output

Performs the indexing (container[index]) operation.

impl Index<Variable> for QuerySolution

type Output = Term

The returned type after indexing.

fn index(&self, index: Variable) -> &<QuerySolution as Index<Variable>>::Output

Performs the indexing (container[index]) operation.

impl Index<VariableRef<'_>> for QuerySolution

type Output = Term

The returned type after indexing.

fn index( &self, index: VariableRef<'_>, ) -> &<QuerySolution as Index<VariableRef<'_>>>::Output

Performs the indexing (container[index]) operation.

impl Index<usize> for QuerySolution

type Output = Term

The returned type after indexing.

fn index(&self, index: usize) -> &<QuerySolution as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl<'a> IntoIterator for &'a QuerySolution

type Item = (&'a Variable, &'a Term)

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a QuerySolution as IntoIterator>::IntoIter

Creates an iterator from a value.

impl PartialEq for QuerySolution

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