This document discusses query rewriting in RDF stream processing. It presents StreamQR, a system that incorporates query rewriting techniques with an RDF stream processor (RSP) to answer queries over ontologies in streams. StreamQR rewrites queries using an ontology and registers the rewritten queries with an RSP. It achieves throughput comparable to no rewriting even for queries with many rewritings. StreamQR performance is evaluated under different workloads and compared to an approach using incremental reasoning. Query rewriting allows efficient query answering over ontologies in RSPs.

1. Query Rewriting in RDF
Stream Processing
Jean-Paul Calbimonte – Jose Mora – Oscar Corcho
LSIR EPFL
OEG UPM
ESWC
Heraklion, Greece. June 2016
@jpcik

2. 2
Query Rewriting in
RDF Stream Processing

3. RDF Streams
3
s p o
Triple
s p o t
Time-stamped triple
s p o
s p o
s p o
t
Time-stamped graph
Gi-1 Gi Gi+1 Gi+2 Gi+3
RDF stream
RSPS
W(S,t)

4. Windowed Queries in RSP
4
:obs1 rdf:type ssn:Observation .
:obs2 rdf:type ssn:Observation .
:obs3 rdf:type ssn:Observation .
qG(x) ← ssn:Observation(x)
:obs1,:obs2 ,:obs3
qW(S,t)(x) ← ssn:Observation(x)
:obs1,:obs2 [5]
:obs3,:obs4 [10]
:obs5,:obs6 [15]
g1[3]
[4]
[7]
[10]
[11]
[13]
:obs1 rdf:type ssn:Observation .
g2 :obs2 rdf:type ssn:Observation .
g3 :obs3 rdf:type ssn:Observation .
g4 :obs4 rdf:type ssn:Observation .
g5 :obs5 rdf:type ssn:Observation .
g6 :obs6 rdf:type ssn:Observation .
[1]
S
G
graph
W
W size=5
qW(S,t)(x) ← ssn:observedBy(x,y)
No answers for this query:
no matches in the stream

5. RSP Query Languages
5
SELECT (MAX(?temp) AS ?maxtemp) ?sensor
WHERE {
STREAM :stream [RANGE 1h] {
?obs ssn:observationResult ?result;
ssn:observedProperty cf-property:air_temperature;
ssn:observedBy ?sensor.
?result ssn:hasValue ?obsValue.
?obsValue qu:numericalValue ?temp.
}
} GROUP BY ?sensor
SELECT ?obs WHERE {
STREAM :stream [RANGE 5s]
{?obs rdf:type ssn:Observation. }
}
CQELS
C-SPARQL
SPARQLStream
EP-SPARQL
RSP languages
Example:
Get the maximum air
temperature
observed in the last
hour, grouped by
sensor.

6. 6
Query Rewriting in
RDF Stream Processing

7. Query Rewriting
7
q’’(x) ← HumiditySensor(x)
Query
Rewriting
q(x) ← Sensor(x)
q’(x) ← Sensor(x)
Sensor
HumiditySensor
TBox
Original Query
Rewritten UCQ
ABox
Ontology expressiveness: e.g. RDFS, ELHIO, etc.
OBDA systems, query rewriters: Prexto, Requiem, Kyrie, etc.
Explosion of rewritings, complexity of queries

8. Semantic Sensor Network Ontology
8
ssn:Sensor
ssn:Platform
ssn:FeatureOfInterest
ssn:Deployment
ssn:Property
cf-prop:air_temperature
ssn:observes
ssn:onPlatform
dul:Place
dul:hasLocation
ssn:SensingDevicessn:inDeployment
ssn:MeasurementCapability
ssn:MeasurementProperty
geo:lat, geo:lng
xsd:double
ssn:hasMeasurementProperty
ssn:Accuracy
ssn:ofFeature
aws:TemperatureSensor
aws:Thermistor
ssn:Latency
dim:Temperature
qu:QuantityKind
cf-prop:soil_temperature
cf-feat:Wind
cf-feat:Surface
cf-
feat:Medium
cf-feat:air
cf-feat:soil
dim:VelocityOrSpeed
cf-prop:wind_speed
cf-prop:rainfall_rate
aws:CapacitiveBead …
…
…

9. Rewriting in RSP
9
:obs1,:obs2 [5]
:obs3,:obs4 [10]
:obs5,:obs6 [15]
g1[3]
[4]
[7]
[10]
[11]
[13]
:obs1 rdf:type ssn:Observation .
g2 :obs2 rdf:type ssn:Observation .
g3 :obs3 rdf:type ssn:Observation .
g4 :obs4 rdf:type ssn:Observation .
g5 :obs5 rdf:type ssn:Observation .
g6 :obs6 rdf:type ssn:Observation .
[1]
q’’W(S,t)(x) ← ssn:Observation(x)
Query
Rewriting
qW(S,t)(x) ← ssn:observedBy(x,y)
q’W(S,t)(x) ← ssn:observedBy(x,y)
Original Query
Rewritten UCQ
ssn:Observation ⊑ ∃ssn:observedBy
S
W(S,t)

10. Rewriting in RSP: Semantics
10
𝑞: 𝑞ℎ 𝒙 ← 𝑝1 ∧ ⋯ ∧ 𝑝 𝑛(𝒙 𝑛)
𝑐𝑒𝑟𝑡 𝑞, 𝒪 = 𝜶 | 𝑞 ∪ 𝒯 ∪ 𝒜 ⊨ 𝑞ℎ(𝜶)
𝑐𝑒𝑟𝑡 𝑞, 𝒪 = 𝜶 | 𝑞′ ∪ 𝒜 ⊨ 𝑞ℎ(𝜶)
Stream: 𝒜 0 , 𝒜 1 , 𝒜 2 , 𝒜 3 … 𝒜 𝑡𝑖 , …
𝒜 𝑤
𝑐𝑒𝑟𝑡 𝑞 𝑤, 𝒯, 𝒜 𝑤 = 𝜶 | 𝑞 𝑤 ∪ 𝒯 ∪ 𝒜 𝑤 ⊨ 𝑞ℎ(𝜶)
𝑐𝑒𝑟𝑡 𝑞 𝑤, 𝒯, 𝒜 𝑤 = 𝜶 | 𝑞′ 𝑤 ∪ 𝒜 𝑤 ⊨ 𝑞ℎ(𝜶)
Query
Certain
answers
Ontology
rewritten
query
get rid of TBox
Streaming Aboxes
Window
Evaluated only for a window
Now for RDF streams:

11. Implementation: StreamQR
11
kyrie
rewriter
CQELS
Ontology
TBOX
StreamQR
query
registration
continuous
answers
CQELS
query
CQELS
UCQ
RDF Stream
Github StreamQR: https://github.com/jpcik/streapler/tree/streamQR

12. StreamQR: Rewriting Steps
12
preprocess
separate BGP
& context
Ontology
TBOX
Datalog
query
CQELS
query
Rewritten
CQELS
UCQ
remove
functional
terms
remove
auxiliary
predicates
expand
syntactic
transformation
UCQ
CQ
(BGP)

13. StreamQR in Action
13
met:TemperatureObservation ⊑ ∃ssn:observedBy.aws:TemperatureSensor
met:AirTemperatureObservation ⊑ met:TemperatureObservation
met:ThermistorObservation ⊑ met:TemperatureObservation
aws:Thermistor ⊑ aws:TemperatureSensor
aws:CapacitiveBead ⊑ aws:TemperatureSensor
TBox
CONSTRUCT { ?o a :ObservedTemperature. }
WHERE {
STREAM :stream1 [RANGE 10ms] {
?o ssn:observedBy ?t .
?t a aws:TemperatureSensor. }
}
Q(?0) <- aws:TemperatureSensor(?1), ssn:observedBy(?0,?1)
kyrie
rewriter
CQELS
Query
CQ extraction & syntactic transformation

14. StreamQR in Action
14
Q(?0) <- met:TemperatureObservation(?0)
Q(?0) <- met:AirTemperatureObservation(?0)
Q(?0) <- met:ThermistorObservation(?0)
Q(?0) <- aws:TemperatureSensor(?1), ssn:observedBy(?0,?1)
Q(?0) <- aws:Thermistor(?1), ssn:observedBy(?0,?1)
Q(?0) <- aws:CapacitiveBead(?1), ssn:observedBy(?0,?1)
Q(?0) <- aws:TemperatureSensor(?1), ssn:observedBy(?0,?1)
met:TemperatureObservation ⊑ ∃ssn:observedBy.aws:TemperatureSensor
met:AirTemperatureObservation ⊑ met:TemperatureObservation
met:ThermistorObservation ⊑ met:TemperatureObservation
aws:Thermistor ⊑ aws:TemperatureSensor
aws:CapacitiveBead ⊑ aws:TemperatureSensor
TBox
Query expansion
Rewritten UCQ

15. StreamQR in Action
15
Q(?0) <- met:TemperatureObservation(?0)
Q(?0) <- met:AirTemperatureObservation(?0)
Q(?0) <- met:ThermistorObservation(?0)
Q(?0) <- aws:TemperatureSensor(?1), ssn:observedBy(?0,?1)
Q(?0) <- aws:Thermistor(?1), ssn:observedBy(?0,?1)
Q(?0) <- aws:CapacitiveBead(?1), ssn:observedBy(?0,?1)
PREFIX ssn: <http://purl.oclc.org/NET/ssnx/ssn#>
PREFIX aws: <http://purl.oclc.org/NET/ssnx/meteo/aws#>
PREFIX met: <http://purl.org/env/meteo#>
CONSTRUCT { ?o a :ObservedTemperature. }
WHERE { STREAM :stream1 [RANGE 10ms] {
{ ?o a met:TemperatureObservation } UNION
{ ?o a met:AirTemperatureObservation } UNION
{ ?o a met:ThermistorObservation } UNION
{ ?s a aws:TemperatureSensor . ?o ssn:observedBy ?s } UNION
{ ?s a aws:Thermistor . ?o ssn:observedBy ?s } UNION
{ ?s a aws:CapacitiveBead . ?o ssn:observedBy ?s }
}
CQELS rewritten
query: syntactic
transformation
Rewritten UCQ

16. Comparison: Rewriting vs No-rewriting
16
0
10000
20000
30000
40000
50000
10 100 1000 10000 100000
throughput[triple/s]
input rate [triple/s]
no rewriting
rewriting
0
5000
10000
15000
20000
25000
30000
10 100 1000 10000 100000
throughput[triple/s]
input rate [triple/s]
no rewriting
rewriting
0
5000
10000
15000
20000
25000
10 100 1000 10000 100000
throughput[triple/s]
input rate [triple/s]
no rewriting
rewriting
• Throughput under different input data loads
• Modified version of the SRBench benchmark queries
• Ontology based on AWS, which extends SSN-O
• Compared the throughput of StreamQR with CQELS (no rewiriting)
• Tested under different input rates, ranging from 10 to 100K triples/s
• Under three different load conditions: such that only:
• 10%, 50% and 90% of the input data matches the continuous query
10% of matches 90% of matches50% of matches
Reaches optimal t-put
up to this point

17. Varying input distributions
17
0
5000
10000
15000
20000
25000
30000
35000
40000
10 100 1000 10000 100000
throughput[triple/s]
input rate[triple/s]
10% match
20% match
50% match
80% match
• The more matches, the more time the engine spends on evaluation
• Up to 10K triples/s., StreamQR is capable to keep up with the input
• Beyond that, the throughput degrades until it reaches a limit
Changning que input
stream triple distribution
• Experiments under different input loads
• Varying distribution of the types of triples
• 10, 20, 50, 80 and 90% of the triples match the query.

18. Throughput for different queries
18
100
1000
10000
100000
100 1000 10000 100000
throughput[triple/s]
input rate[triple/s]
q4
q6
q1
q5
q2
q3
q7
q10
Different queries prducing
from 2 to 180 rewritings
• Throughput decreases for queries that produce more rewrittings
• Optimizations: existing techniques used in query rewriting and OBDA
• Pruning queries that may not match any input.
• For around 1K triples/s, it still reaches maximum throughput.
• Different queries -> UCQ with a different number of sub-queries.
• 9 distinct queries that produce from 2 to over 180 sub-queries

19. Comparing with TrOwl
19
100
1000
10000
100000
100 1000 10000 100000
throughput[triple/s]
input rate[triple/s]
StreamQR
Trowl-no-reclassify
Trowl-only-add
Trowl-add-remove
• Removal operation known to be expensive in incremental materialization
• StreamQR sustains better throughput under fast input rates
• Under lower input rates both are able to reach maximum throughput.
• TrOWL Provides incremental reasoning for ABoxes
• Three settings:
• TrOWL without performing any reasoning (noreclassify)
• Activating the reasoning, but allowing only additions
• Including removals

20. Conclusions
20
• Query answering over ontologies for RDF stream processors
• Novel approach that combines query rewriting techniques and an
RSP engines
• Implemented StreamQR: incorporates the kyrie into an existing RSP
• Still efficient in terms of throughput, for a large range of scenarios
• Plan to study other criteria such as correctness
• Exploring different expressiveness
• Find a good balance between efficiency and complexity.
• Research in approaches that combine rewriting and incremental
materialization

21. Thanks a lot!
¿Tienes preguntas?
Jean-Paul Calbimonte
LSIR EPFL
@jpcik