SEKE 2012 Proceedings - Knowledge Systems Institute

query into several sub-queries without any Alternative Graph
Pattern.
B. Indices Creation of SPARQL Query
Based on SPARQL basics as discussed above, we present a
method to create indices for a given SPARQL query to locate
useful ontology for it. The method just concerns the query
without Alternative Graph Pattern because the query with such
pattern can be broken into se veral sub-queries without such
pattern to substitute for it. It consists of the following steps:
1) given a SPARQL query, extracts its graph pattern GP.
2) from graph pattern GP, removes Optional and Named
Graph Patterns in it, as a graph pattern G.
3) converts graph pattern G into a tr iple pattern TP. For
example, the conversion from Figure 1 to Figure 2.
4) from each triple T in triple pattern TP, first takes out
each RDF term tm, which are not blank nodes, variables, or
vocabularies of ontology language, such as OWL. Then,
records RDF term tm and its role Ro(as one of subject,
predicate, and object) in the triple T as a pair . Thus,
given a query’s triple pattern, we can obtain a pair set, called
tmRoPairs.
RDF terms in pairs in tmRoPairs are also referred to as
entities, which are classes, properties, or individuals in web
ontology to express the notions in domain. Here, each pair in
tmRoPairs is reviewed as an index of its SPARQL query.
Based on S PARQL basics as discussed in subsection 3.1, we
can draw a conclusion as follows:
Conclusion 1: If a web ontology is likely reasoned out
results for a q uery, then for each pair P in the query’s
tmRoPairs, the ontology must specify or can be reasoned out a
triple T, which contains the RDF term tm in pair P, and tm’s
role in triple T is identical to the role in pair P.
For a pair P in a query’s tmRoPairs, if a web ontology
neither specify nor can be reasoned out such a triple T, it means
that a triple in the query’s triple pattern, from which pair P is
constructed, must not be matched in the ontology. So, the
ontology must not be reasoned out solutions for the query.
C. Web Ontology Publication
To locate web ontologies according to conclusion 1, we
publish an ontology based on each entity and one of its possible
roles which appear in a specified or implied RDF triple in the
ontology. The process is listed as follows:
1) given sharable ontology O, extracts the entities as a set
enSet, which appear in ontology O.
2) for each entity E in set enSet, reasons the ontology to
determine whether there is at least one specified or implied
triple where entity E’s role is subject (predicate, or object). If
such a triple exists, puts E into subSet (preSet, or objSet).
3) takes each element E in set subset (objSet, proSet) and
its corresponding role subject (predicate, object) as a pair . Then, views the pair as an
index idx of ontology O.
4) according to each idx, publishes the IRI onto of
ontology O by using the function pubOnto(idx, onto) as
discussed in subsection 2.1.
D. Web Ontology Location
Based on conclusion 1 and ontology publication method in
subsection 3.3, we design algorithm ontoLocating in Figure 3
to locate ontologies useful to a given SPAQRL query. Its basic
idea is that, given a query Q, we first discover ontologies based
on each pair P in its tmRoPairs defined in subsection 3.2, and
then intersect them as a set of useful ontologies to process
query Q.
1. Algorithm ontoLocating
2. Input qry: a given SPARQL query.
3. Output ontos: a set of IRIs of ontologies useful to query qry.
4. Begin
5. sets integer i=0 ;
6. parses out set tmRoPairs from graph pattern of qry;
7. For each pair p in set tmRoPairs Do
8. i=i+1;
9. creates a index idx based on the entity and its role in p;
10. retrieves a set ontoSet by using function lookupOnto (idx);
11. If i=1 Then ontos = ontoSet Else
12. ontos = ontoSetontos
13. End If
14. End Do
15. Return ontos;
16. End
Figure 3. Algorithm: ontoLocating
In this algorithm, to process a given query, the number that
the algorithms access P2P network is the number of pairs in
tmRoPairs.
IV. EVALUATION
To evaluate our approach, first we have implemented it.
Then, design the following two experiments to evaluate its
efficiency:
1) Experiment 1 evaluates our approach’s consumption of
network resources when ontology is published.
2) Experiment 2 evaluates our approach’s consumption of
network resources when query is processed.
A. Experiment Set Up
In our experiments, first we downloaded 16 web ontologies
from TONES [13], an ontology repository, as experimental
data, which are listed in Table I. Then, we design 15 SPARQL
queries using the entities, which come from the ontologies in
Table I.
In addition, we compare the consumption of network
resources of our approach M1 with approach M2 and M3. For a
same task, if an approach consumes fewer resources, it will be
superior. Here, the consumption of network resources refers to
the number of accesses to P2P network and quantity of values
publishing on o r retrieving from P2P network when a web
ontology is published, or a query is processed. As far as
approach M2 and M3 are concerned, they are all implemented
based on RDFPeers [14], a structured P2P-based RDF
repositories. RDFPeers stores each RDF triple at three places
619