net.fortytwo.stream.sparql

Class SparqlStreamProcessor<Q>

java.lang.Object

net.fortytwo.stream.BasicStreamProcessor<String,C,Q,org.openrdf.model.Statement,org.openrdf.query.BindingSet>

net.fortytwo.stream.sparql.RDFStreamProcessor<SparqlQuery,Q>

net.fortytwo.stream.sparql.SparqlStreamProcessor<Q>

All Implemented Interfaces:

StreamProcessor<String,org.openrdf.model.Statement,org.openrdf.query.BindingSet>

Direct Known Subclasses:

CachingSparqlStreamProcessor, SHJSparqlStreamProcessor

public abstract class SparqlStreamProcessor<Q>
extends RDFStreamProcessor<SparqlQuery,Q>

An RDF stream processor with SPARQL 1.1 support. The processor consumes SPARQL queries and RDF statements, producing SPARQL solutions.

Author:

Joshua Shinavier (http://fortytwo.net)

Nested Class Summary

Nested classes/interfaces inherited from class net.fortytwo.stream.sparql.RDFStreamProcessor

RDFStreamProcessor.Counter, RDFStreamProcessor.Quantity

Nested classes/interfaces inherited from interface net.fortytwo.stream.StreamProcessor

StreamProcessor.IncompatibleQueryException, StreamProcessor.InvalidQueryException

Field Summary

Fields inherited from class net.fortytwo.stream.sparql.RDFStreamProcessor

logger

Fields inherited from interface net.fortytwo.stream.StreamProcessor

INFINITE_TTL, NEVER_EXPIRE

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	SparqlStreamProcessor()

Method Summary

Modifier and Type	Method and Description
Subscription	addQuery(int ttl, org.openrdf.query.algebra.TupleExpr tupleExpr, java.util.function.BiConsumer<org.openrdf.query.BindingSet,Long> consumer) Adds a new query, as a pre-parsed TupleExpr to this query engine, returning a subscription
protected boolean	addTuple(org.openrdf.model.Value[] tuple, int ttl, long now) Adds a tuple to an internal index, possibly generating new solutions
protected abstract boolean	addTupleInternal(org.openrdf.model.Value[] tuple, int ttl, long now)
org.openrdf.rio.RDFHandler	createRDFHandler(int ttl)
protected BasicSubscription<SparqlQuery,Q,org.openrdf.query.BindingSet>	createSubscription(int ttl, SparqlQuery sparqlQuery, java.util.function.BiConsumer<org.openrdf.query.BindingSet,Long> consumer)
protected abstract BasicSubscription<SparqlQuery,Q,org.openrdf.query.BindingSet>	createSubscriptionInternal(SparqlQuery q, List<VariableOrConstant<String,org.openrdf.model.Value>[]> patterns, long expirationTime, java.util.function.BiConsumer<org.openrdf.query.BindingSet,Long> consumer)
static long	getReducedModifierCapacity()
protected void	handleCandidateSolution(BasicSubscription<SparqlQuery,Q,org.openrdf.query.BindingSet> subscription, org.openrdf.query.BindingSet bs, long expirationTime)
protected SparqlQuery	parseQuery(String queryStr)
protected abstract void	register(BasicSubscription<SparqlQuery,Q,org.openrdf.query.BindingSet> subscription)
void	setLinkedDataCache(net.fortytwo.linkeddata.LinkedDataCache cache) Adds a Linked Data fetching and caching layer to this query engine.
static void	setReducedModifierCapacity(long capacity) Sets the REDUCED capacity.
protected abstract void	visitQueryPatterns(Q query, java.util.function.Consumer<VariableOrConstant<String,org.openrdf.model.Value>[]> visitor)

Methods inherited from class net.fortytwo.stream.sparql.RDFStreamProcessor

addInputs, addQuery, addQueryNative, beginOperation, clearCounters, get, getNow, handleSolution, increment, incrementQueries, incrementSolutions, incrementStatements, isActive, logEntry, logHeader, setClock, setDoPerformanceMetrics, setDoUseCompactLogFormat, shutDown, toExpirationTime

Methods inherited from class net.fortytwo.stream.BasicStreamProcessor

renew, unregister

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface net.fortytwo.stream.StreamProcessor

clear

Constructor Detail

SparqlStreamProcessor

protected SparqlStreamProcessor()

Method Detail

getReducedModifierCapacity

public static long getReducedModifierCapacity()

Returns:

the number of distinct solutions which each query subscription can store before it begins recycling them For a SELECT DISTINCT query, the set of distinct solution grows without bound, but a duplicate answer will never appear in the output stream. However, for a SELECT REDUCED query, the set of distinct solutions is limited in size(). This is much safer with respect to memory consumption, although duplicate solutions may eventually appear in the output stream.

setReducedModifierCapacity

public static void setReducedModifierCapacity(long capacity)

Sets the REDUCED capacity.

Parameters:

capacity - the number of distinct solutions which each query subscription can store before it begins recycling them

visitQueryPatterns

protected abstract void visitQueryPatterns(Q query,
                                           java.util.function.Consumer<VariableOrConstant<String,org.openrdf.model.Value>[]> visitor)

addTupleInternal

protected abstract boolean addTupleInternal(org.openrdf.model.Value[] tuple,
                                            int ttl,
                                            long now)

register

protected abstract void register(BasicSubscription<SparqlQuery,Q,org.openrdf.query.BindingSet> subscription)

createSubscriptionInternal

protected abstract BasicSubscription<SparqlQuery,Q,org.openrdf.query.BindingSet> createSubscriptionInternal(SparqlQuery q,
                                                                                                            List<VariableOrConstant<String,org.openrdf.model.Value>[]> patterns,
                                                                                                            long expirationTime,
                                                                                                            java.util.function.BiConsumer<org.openrdf.query.BindingSet,Long> consumer)

addTuple

protected boolean addTuple(org.openrdf.model.Value[] tuple,
                           int ttl,
                           long now)

Description copied from class: RDFStreamProcessor

Adds a tuple to an internal index, possibly generating new solutions

Specified by:

addTuple in class RDFStreamProcessor<SparqlQuery,Q>

Parameters:

tuple - the tuple to add

ttl - the time-to-live in seconds

now - the current time in milliseconds

Returns:

whether the addition of the tuple changed the state of the index

createRDFHandler

public org.openrdf.rio.RDFHandler createRDFHandler(int ttl)

setLinkedDataCache

public void setLinkedDataCache(net.fortytwo.linkeddata.LinkedDataCache cache)

Adds a Linked Data fetching and caching layer to this query engine. Once added, the Linked Data cache will listen for new triple patterns indexed by this query engine, and issue corresponding HTTP requests for additional information about IRIs in those patterns. Any RDF statements from retrieved documents are passed into the query engine, where they may contribute to query results and/or partial solutions, and may trigger further HTTP requests.

Parameters:

cache - a collection of caching metadata about Linked Data already retrieved

addQuery

public Subscription addQuery(int ttl,
                             org.openrdf.query.algebra.TupleExpr tupleExpr,
                             java.util.function.BiConsumer<org.openrdf.query.BindingSet,Long> consumer)
                      throws StreamProcessor.IncompatibleQueryException,
                             IOException

Adds a new query, as a pre-parsed TupleExpr to this query engine, returning a subscription

Parameters:

ttl - the time-to-live in seconds

tupleExpr - the query to add

consumer - a handler for future query answers

Returns:

a subscription for computation of future query answers

Throws:

IncompatibleQueryException - if the syntax of the query is not supported by this engine

StreamProcessor.IncompatibleQueryException

IOException

createSubscription

protected BasicSubscription<SparqlQuery,Q,org.openrdf.query.BindingSet> createSubscription(int ttl,
                                                                                           SparqlQuery sparqlQuery,
                                                                                           java.util.function.BiConsumer<org.openrdf.query.BindingSet,Long> consumer)

Specified by:

createSubscription in class RDFStreamProcessor<SparqlQuery,Q>

parseQuery

protected SparqlQuery parseQuery(String queryStr)
                          throws StreamProcessor.InvalidQueryException,
                                 StreamProcessor.IncompatibleQueryException

Specified by:

parseQuery in class RDFStreamProcessor<SparqlQuery,Q>

Throws:

StreamProcessor.InvalidQueryException

StreamProcessor.IncompatibleQueryException

handleCandidateSolution

protected void handleCandidateSolution(BasicSubscription<SparqlQuery,Q,org.openrdf.query.BindingSet> subscription,
                                       org.openrdf.query.BindingSet bs,
                                       long expirationTime)
                                throws IOException

Throws:

IOException