Struct BoundPreparedSparqlQuery 

pub struct BoundPreparedSparqlQuery<'a, D = DatasetView<'a>>
where
    D: QueryableDataset<'a>,
{
    evaluator: QueryEvaluator,
    query: Query,
    queryable_dataset: D,
    substitutions: HashMap<Variable, Term>,
    dataset: QueryDatasetSpecification,
    marker: PhantomData<&'a ()>,
}

Available on crate feature rdf only.

A prepared SPARQL query bound to a storage, ready to be executed.

Usage example:

use oxigraph::model::{Literal, Variable};
use oxigraph::sparql::{QueryResults, SparqlEvaluator};
use oxigraph::store::Store;

let prepared_query = SparqlEvaluator::new()
    .parse_query("SELECT ?v WHERE {}")?
    .substitute_variable(Variable::new("v")?, Literal::from(1));

if let QueryResults::Solutions(mut solutions) =
    prepared_query.on_store(&Store::new()?).execute()?
{
    assert_eq!(
        solutions.next().unwrap()?.get("v"),
        Some(&Literal::from(1).into())
    );
}

Fields

evaluator: QueryEvaluator

query: Query

queryable_dataset: D

substitutions: HashMap<Variable, Term>

dataset: QueryDatasetSpecification

marker: PhantomData<&'a ()>

Implementations

impl<'a, D> BoundPreparedSparqlQuery<'a, D>

where D: QueryableDataset<'a>,

pub fn substitute_variable( self, variable: impl Into<Variable>, term: impl Into<Term>, ) -> BoundPreparedSparqlQuery<'a, D>

Substitute a variable with a given RDF term in the SPARQL query.

Usage example:

use oxigraph::model::{Literal, Variable};
use oxigraph::sparql::{QueryResults, SparqlEvaluator};
use oxigraph::store::Store;

let prepared_query = SparqlEvaluator::new()
    .parse_query("SELECT ?v WHERE {}")?
    .on_store(&Store::new()?)
    .substitute_variable(Variable::new("v")?, Literal::from(1));

if let QueryResults::Solutions(mut solutions) = prepared_query.execute()? {
    assert_eq!(
        solutions.next().unwrap()?.get("v"),
        Some(&Literal::from(1).into())
    );
}

pub fn execute(self) -> Result<QueryResults<'a>, QueryEvaluationError>

Evaluate the query against the given store.

pub fn compute_statistics(self) -> BoundPreparedSparqlQuery<'a, D>

Compute statistics during evaluation and fills them in the explanation tree.

pub fn explain( self, ) -> (Result<QueryResults<'a>, QueryEvaluationError>, QueryExplanation)

Executes a SPARQL 1.1 query with some options and returns a query explanation with some statistics (if enabled with the compute_statistics option).

If you want to compute statistics, you need to exhaust the results iterator before having a look at them.

Usage example serializing the explanation with statistics in JSON:

use oxigraph::sparql::{QueryResults, SparqlEvaluator};
use oxigraph::store::Store;

if let (Ok(QueryResults::Solutions(solutions)), explanation) = SparqlEvaluator::new()
    .parse_query("SELECT ?s WHERE { VALUES ?s { 1 2 3 } }")?
    .on_store(&Store::new()?)
    .explain()
{
    // We make sure to have read all the solutions
    for _ in solutions {}
    let mut buf = Vec::new();
    explanation.write_in_json(&mut buf)?;
}