Trait DefaultServiceHandler

pub trait DefaultServiceHandler: Send + Sync {
    type Error: Error + Send + Sync + 'static;

    // Required method
    fn handle(
        &self,
        service_name: NamedNode,
        pattern: GraphPattern,
        base_iri: Option<String>,
    ) -> Result<QuerySolutionIter, Self::Error>;
}

Default handler for SPARQL 1.1 Federated Query SERVICEs.

Should be given to QueryOptions before evaluating a SPARQL query that uses SERVICE calls.

Note that you can also use ServiceHandler if you need to handle a single service and not any service.

use oxrdf::{Dataset, NamedNode, Variable};
use sparesults::QuerySolution;
use spareval::{DefaultServiceHandler, QueryEvaluator, QueryResults, QuerySolutionIter};
use spargebra::algebra::GraphPattern;
use spargebra::Query;
use std::convert::Infallible;
use std::iter::once;
use std::sync::Arc;

struct TestServiceHandler {}

impl DefaultServiceHandler for TestServiceHandler {
    type Error = Infallible;

    fn handle(
        &self,
        service_name: NamedNode,
        _pattern: GraphPattern,
        _base_iri: Option<String>,
    ) -> Result<QuerySolutionIter, Self::Error> {
        // Always return a single binding name -> name of service
        let variables = [Variable::new_unchecked("foo")].into();
        Ok(QuerySolutionIter::new(
            Arc::clone(&variables),
            once(Ok(QuerySolution::from((
                variables,
                vec![Some(service_name.into())],
            )))),
        ))
    }
}

let evaluator = QueryEvaluator::default().with_default_service_handler(TestServiceHandler {});
let query = Query::parse(
    "SELECT ?foo WHERE { SERVICE <http://example.com/service> {} }",
    None,
)?;
if let QueryResults::Solutions(mut solutions) = evaluator.execute(Dataset::new(), &query)? {
    assert_eq!(
        solutions.next().unwrap()?.get("foo"),
        Some(&NamedNode::new("http://example.com/service")?.into())
    );
}

Required Associated Types

type Error: Error + Send + Sync + 'static

The service evaluation error.

Required Methods

fn handle( &self, service_name: NamedNode, pattern: GraphPattern, base_iri: Option<String>, ) -> Result<QuerySolutionIter, Self::Error>

Evaluates a GraphPattern against a given service identified by a NamedNode.

Implementors