root/BH13SPARQLBuilder/src/org/biohackathon/SPARQLBuilder/OWL/OWLQueryBuilderImpl.java @ 58

リビジョン 58, 35.6 KB (コミッタ: wu, 11 年 前)

keywords のOR　relationship 実装しました
  • 属性 svn:mime-type の設定値 text/plain
行番号 
1package org.biohackathon.SPARQLBuilder.OWL;
2
3import java.util.ArrayList;
4import java.util.Collection;
5import java.util.HashMap;
6import java.util.HashSet;
7import java.util.Set;
8
9import com.hp.hpl.jena.query.Query;
10import com.hp.hpl.jena.query.QueryExecution;
11import com.hp.hpl.jena.query.QueryExecutionFactory;
12import com.hp.hpl.jena.query.QueryFactory;
13import com.hp.hpl.jena.query.QuerySolution;
14import com.hp.hpl.jena.query.ResultSet;
15import com.hp.hpl.jena.rdf.model.Literal;
16import com.hp.hpl.jena.rdf.model.Resource;
17
18/**
19 * 繧ｯ繧ｨ繝ｪ繧堤函謌舌☆繧九◆繧√�讖溯�繧呈署萓帙☆繧区ｸ繧ｯ繝ｩ繧ｹ
20 *
21 * @author Norio KOBAYASHI
22 * @since 28.01.2014
23 * @version 29.01.2014
24 */
25public class OWLQueryBuilderImpl implements OWLQueryBuilder {
26
27        // private Model model = null;
28        private String endpointURI = null;
29
30        /**
31         * 繧｢繧ｯ繧ｻ繧ｹ縺吶ｋSPARQL endpoint縺ｮURI繧呈欠螳壹☆繧区ｧ区�蟄�
32         *
33         * @param endpointURI
34         *            縲€繧｢繧ｯ繧ｻ繧ｹ縺吶ｋSPARQL endpoint縺ｮURI
35         * @throws Exception
36         * @since 28.01.2014
37         */
38        public OWLQueryBuilderImpl(String endpointURI) {
39                this.endpointURI = endpointURI;
40        }
41
42        /**
43         * 繝�せ繝医↓菴ｿ逕ｨ縺吶ｋmain繝｡繧ｽ繝�ラ
44         * <p>
45         * 繧ｯ繧ｨ繝ｪ繝薙Ν繝€繝ｼ縺ｮ譛ｬ逡ｪ繝励Ο繧ｰ繝ｩ繝縺ｧ縺ｯ縺薙�繝｡繧ｽ繝�ラ縺ｯ菴ｿ逕ｨ縺励↑縺�
46         * </p>
47         *
48         * @param args
49         *            菴ｿ逕ｨ縺励↑縺�
50         * @throws Exception
51         * @since 28.01.2014
52         */
53        public static void main(String[] args) throws Exception {
54                // String sparqlEndpoint = "http://dbpedia.org/sparql";
55                String sparqlEndpoint = "http://lsd.dbcls.jp/sparql";
56                // String keyword = "artiste";
57                String[] keyword = {"Player","Soccer"};
58                String[] graphURIs = new String[0];
59
60                //keyword = null;
61
62                OWLQueryBuilder builder = new OWLQueryBuilderImpl(sparqlEndpoint);
63     
64                builder.getOWLClasses(null,keyword,false);
65/*
66                SClass[] clz = builder.getOWLClasses(graphURIs, keyword, false);
67                for (SClass cls : clz) {
68                        System.out.println(cls);
69                }
70                clz = builder.countInstances(null, clz);
71                for (SClass cls : clz) {
72                        System.out.println(cls);
73                }
74*/
75
76
77        /*      System.out.println("CLS");
78
79                String uri = "http://purl.jp/bio/10/lsd/ontology/201209#EnglishEntry";
80               
81                ClassLink[] cls = null;
82                try{
83                        cls = builder.getNextClass(null, uri, 100, false);
84                }catch(Exception ex) {
85                        ex.printStackTrace();
86                }
87
88                System.out.println("Solutions: ");
89                if (cls != null) {
90                        for (ClassLink cl : cls) {
91                                System.out.println(cl.toString());
92                        }
93                        cls = builder.countLinks(null, uri, cls);
94                        for (ClassLink cl : cls) {
95                                System.out.println(cl.toString());
96                        }
97                }
98*/
99/*
100               
101                String uri = "http://purl.jp/bio/10/lsd/ontology/201209#EnglishEntry";
102               
103                ClassLink[] cls = null;
104               
105                System.out.println("CLS-INS");
106                cls = null;
107                try{
108                        cls = builder.getNextClassViaInstanceLink(null, uri, 100);
109                }catch(Exception ex){
110                        ex.printStackTrace();
111                }
112                if (cls != null) {
113                        for (ClassLink cl : cls) {
114                                System.out.println(cl.toString());
115                        }
116                }
117*/
118                /*
119                System.out.println("Instances");
120                Instance[] ins = builder.getInstances(null, "\"A.C. Reed\"@en");
121                if (ins != null) {
122                        for (Instance in : ins) {
123                                System.out.println(in.toString());
124                        }
125                }
126*/
127                /*
128                 * System.out.println("INS-INS"); ins = builder.getInstances(null,
129                 * "\"A.C. Reed\"@en"); InstanceLink[] iLinks =
130                 * builder.getNextInstancesViaInstanceLink(null,
131                 * ins[0].getInstanceURI(), 100);
132                 *
133                 * if (iLinks != null) { for (InstanceLink in : iLinks) {
134                 * System.out.println(in.toString()); } }
135                 */
136        }
137
138       
139       
140       
141        /**
142         * 譏守､ｺ逧�↓RDF縺ｧ譖ｸ縺九ｌ縺ｦ縺�ｋ繧ｯ繝ｩ繧ｹ繧貞叙蠕励☆繧�
143         * <p>
144         * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧ｯ繝ｩ繧ｹ��dfs:Class�峨ｒ縺吶∋縺ｦ霑斐☆ <br>
145         * </p>
146         *
147         * @param graphURIs
148         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� (null繧�聞縺�縺ｮ驟榊�繧ょ庄)
149         * @param keyword
150         *            ��ull繧�ｩｺ譁�ｭ励�荳榊庄��
151         * @return 繧ｯ繝ｩ繧ｹURI縺ｮ驟榊�
152         * @throws Exception
153         * @since 28.01.2014
154         */
155        public SClass[] getOWLClasses(String[] graphURIs, String[] keywords,
156                        boolean countInstances) throws Exception {
157                StringBuffer queryStr = new StringBuffer();
158                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
159                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
160                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
161                if (countInstances) {
162                        queryStr.append("SELECT DISTINCT ?c ?pLabel (COUNT(?i) AS ?numOfInstances)\n");
163                } else {
164                        queryStr.append("SELECT DISTINCT ?c ?pLabel \n");
165                }
166                if (graphURIs != null) {
167                        for (String graphURI : graphURIs) {
168                                queryStr.append("FROM <");
169                                queryStr.append(graphURI);
170                                queryStr.append(">\n");
171                        }
172                }
173                queryStr.append("WHERE{\n");
174
175                //
176                queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n");
177//              queryStr.append("  ?i rdf:type ?c.\n");
178
179       
180                if (countInstances) {
181                        queryStr.append("  ?c rdfs:label ?label.\n");
182                }
183                queryStr.append("  ?c rdfs:label ?pLabel.\n");
184                if (countInstances) {
185                        queryStr.append("      ?i rdf:type ?c.\n");
186                }
187                // queryStr.append("      ?c rdfs:label ");
188                // queryStr.append(keyword);
189                // queryStr.append(".");
190               
191                // TODO  OR relationship between keywords
192                if (keywords != null && keywords.length != 0) {
193                                                                         
194                        queryStr.append(" ?c rdfs:label ");
195                    queryStr.append("?keywords")
196                                 .append(".\n");
197                        queryStr.append("  filter(");
198                       
199                          for (int i=0;i<keywords.length;i++)
200                          {
201                        if (i>0) queryStr.append(" or \n ");
202                       
203                          queryStr.append("regex(str(")
204                                 .append("?keywords")
205                                 .append("),\"");
206                          queryStr.append(keywords[i]);
207                          queryStr.append("\", \"i\" )");
208                         
209                          }
210                          queryStr.append(")\n");
211       
212                }
213               
214                if (countInstances) {
215                        queryStr.append("}  GROUP BY ?c ?pLabel");
216                } else {
217                        queryStr.append("}");
218                }
219                System.out.println(queryStr.toString());
220               
221               
222        /*      Query query = QueryFactory.create(queryStr.toString());
223
224               
225                QueryExecution qexec = null;
226                try{
227                        long start = System.currentTimeMillis();
228                        qexec = QueryExecutionFactory.sparqlService(endpointURI,
229                                        query);
230                        long end = System.currentTimeMillis();
231                        System.out.println("EXEC TIME: " + (end-start));
232                }catch(Exception ex){
233                        ex.printStackTrace();
234                        throw ex;
235                }
236
237                ResultSet results = qexec.execSelect();
238                HashMap<String, SClass> classMap = new HashMap<String, SClass>();
239                for (; results.hasNext();) {
240                        QuerySolution sol = results.next();
241                        Resource res = sol.getResource("c");
242                        if (res != null) {
243                                String uri = res.getURI();
244                                int numOfInstances = 0;
245                                if (countInstances) {
246                                        numOfInstances = sol.getLiteral("numOfInstances").getInt();
247                                }
248                                // System.out.println(numOfInstances);
249                                Literal labelLiteral = sol.getLiteral("pLabel");
250                                SClass sClass = null;
251                                if (classMap.containsKey(uri)) {
252                                        sClass = classMap.get(uri);
253                                } else {
254                                        sClass = new SClass(uri, null, numOfInstances);
255                                        classMap.put(uri, sClass);
256                                }
257                                if (labelLiteral != null) {
258                                        String label = labelLiteral.getString();
259                                        String lang = labelLiteral.getLanguage();
260                                        sClass.addLabel(new Label(label, lang));
261                                }
262                        }
263                }
264                qexec.close();
265                return classMap.values().toArray(new SClass[0]);*/
266                return null;
267        }
268
269        public SClass[] listClasses(String[] graphURIs, boolean countInstances) throws Exception{
270
271                //TODO
272                return null;
273        }
274
275       
276       
277        /**
278         * 縲€繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧貞叙蠕励☆繧�
279         * <p>
280         * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧偵☆縺ｹ縺ｦ霑斐☆ <br>
281         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
282         * </p>
283         *
284         * @param graphURIs
285         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� (null繧�聞縺�縺ｮ驟榊�繧ょ庄)
286         * @param keyword
287         *            ��ull繧�ｩｺ譁�ｭ励�荳榊庄��
288         * @return 繧ｯ繝ｩ繧ｹURI縺ｮ驟榊�
289         * @throws Exception
290         * @since 28.01.2014
291         */
292        public Instance[] getInstances(String[] graphURIs, String keyword)
293                        throws Exception {
294                StringBuffer queryStr = new StringBuffer();
295                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
296                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
297                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
298                queryStr.append("SELECT DISTINCT ?ins ?c \n");
299                if (graphURIs != null) {
300                        for (String graphURI : graphURIs) {
301                                queryStr.append("FROM <");
302                                queryStr.append(graphURI);
303                                queryStr.append(">\n");
304                        }
305                }
306                queryStr.append("WHERE{\n");
307                // queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n");
308
309                queryStr.append("      ?ins rdf:type ?c.\n");
310                queryStr.append("      ?ins rdfs:label ");
311                queryStr.append(keyword);
312                queryStr.append(".\n");
313                queryStr.append(" FILTER (?c != rdf:Property)");
314                queryStr.append("}");
315
316                // System.out.println(queryStr.toString());
317
318                Query query = QueryFactory.create(queryStr.toString());
319                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
320                                query);
321
322                ResultSet results = qexec.execSelect();
323                HashMap<String, HashSet<String>> instanceMap = new HashMap<String, HashSet<String>>();
324                for (; results.hasNext();) {
325                        QuerySolution sol = results.next();
326                        Resource cls = sol.getResource("c");
327                        Resource ins = sol.getResource("ins");
328                        String clsURI = cls.getURI();
329                        String insURI = ins.getURI();
330                        if (instanceMap.containsKey(insURI)) {
331                                HashSet<String> classes = instanceMap.get(insURI);
332                                classes.add(clsURI);
333                        } else {
334                                HashSet<String> classes = new HashSet<String>();
335                                instanceMap.put(insURI, classes);
336                                classes.add(clsURI);
337                        }
338                }
339                qexec.close();
340                Set<String> keySet = instanceMap.keySet();
341                ArrayList<Instance> instanceList = new ArrayList<Instance>();
342                for (String key : keySet) {
343                        Instance ins = new Instance(key, instanceMap.get(key).toArray(
344                                        new String[0]));
345                        instanceList.add(ins);
346                }
347                return instanceList.toArray(new Instance[0]);
348        }
349
350        /**
351         * 縲€謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€∵�遉ｺ逧�↓險倩ｿｰ縺輔ｌ縺ｦ縺�ｋOWL縺ｮproperty蛻ｶ邏�ｒ隱ｿ縺ｹ縲√◎縺ｮproperty蛻ｶ邏�〒
352         * 髢｢騾｣縺･縺代ｉ繧後※縺�ｋ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
353         * <p>
354         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
355         * <br>
356         * </p>
357         *
358         * @param graphURIs
359         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
360         * @param originClass
361         *            襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲€��ull荳榊庄��
362         * @param limit
363         *            隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
364         * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
365         * @throws Exception
366         * @since 28.01.2014
367         */
368        public ClassLink[] getNextClass(String[] graphURIs, String originClass,
369                        int limit, boolean countLinks) throws Exception {
370                ClassLink[] cLinks = getNextClassSub(graphURIs, originClass, limit, false);
371                if( countLinks ){
372                        cLinks = countLinks(graphURIs, originClass, cLinks);
373                }
374                return cLinks;
375        }
376
377        private ClassLink[] getNextClassSub(String[] graphURIs, String originClass,
378                        int limit, boolean countLinks) throws Exception {
379                                StringBuffer queryStr = new StringBuffer();
380                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
381                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
382                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
383
384                // SELECT
385                if (countLinks) {
386                        queryStr.append("SELECT DISTINCT ?p ?pDirection ?c (COUNT(?oci) AS ?numOfOriginalClassInstances) (COUNT(?lci) AS ?numOfLinkedClassInstances) (COUNT(?s) AS ?numOfLinks) (COUNT(DISTINCT(?s)) AS ?numOfLinkedInstances) \n");
387                } else {
388                        queryStr.append("SELECT DISTINCT ?p ?pDirection ?c \n");
389                }
390
391                if (graphURIs != null) {
392                        for (String graphURI : graphURIs) {
393                                queryStr.append("FROM <");
394                                queryStr.append(graphURI);
395                                queryStr.append(">\n");
396                        }
397                }
398                queryStr.append("WHERE{\n");
399                // queryStr.append("  { ?c rdf:type rdfs:Class. }\n  UNION\n  { ?c rdf:type owl:Class. }\n");
400                queryStr.append("  { ?p rdfs:domain <");
401                queryStr.append(originClass);
402                queryStr.append(">.\n    ?p rdfs:range ?c.\n");
403
404                if (countLinks) {
405                        queryStr.append("    ?o ?p ?s.");
406                } else {
407                        queryStr.append("filter(exists{\n");
408                        queryStr.append("  ?o rdf:type ?c.\n");
409                        queryStr.append(" ?s rdf:type <");
410                        queryStr.append(originClass);
411                        queryStr.append(">.\n");
412                        queryStr.append("       ?s ?p ?o.})\n");
413                }
414
415                queryStr.append("}\n  UNION\n");
416                queryStr.append("  { ?p rdfs:range <");
417                queryStr.append(originClass);
418                queryStr.append(">.\n");
419                queryStr.append("    ?p rdfs:domain ?c.\n");
420
421                if (countLinks) {
422                        queryStr.append("    ?s ?p ?o.");
423                } else {
424                        queryStr.append("filter(exists{\n");
425                        queryStr.append("  ?s rdf:type ?c.\n");
426                        queryStr.append(" ?o rdf:type <");
427                        queryStr.append(originClass);
428                        queryStr.append(">.\n");
429                        queryStr.append("       ?s ?p ?o.})\n");
430                }
431
432                queryStr.append("}\n");
433
434                queryStr.append("    ?p ?pDirection ?c.\n");
435
436//              queryStr.append("  ?s rdf:type ?c.\n");
437
438                if (countLinks) {
439                        queryStr.append("}\nGROUP BY ?p ?pDirection ?c\n");
440                } else {
441                        queryStr.append("}\n");
442                }
443                if (limit > 0) {
444                        queryStr.append("limit ");
445                        queryStr.append(limit);
446                        queryStr.append("\n");
447                }
448
449                System.out.println("getNextClasses SPARQL Query: ");
450                System.out.println(queryStr.toString());
451
452                Query query = QueryFactory.create(queryStr.toString());
453                QueryExecution qexec = null;
454                try{
455                        qexec = QueryExecutionFactory.sparqlService(endpointURI,
456                                query);
457                }catch(Exception ex){
458                        ex.printStackTrace();
459                        throw ex;
460                }
461                       
462                ResultSet results = null;
463                try{
464                        long start = System.currentTimeMillis();
465                        results = qexec.execSelect();
466                        long end = System.currentTimeMillis();
467                        System.out.println("EXEC TIME: " + (end-start));
468                }catch(Exception ex){
469                        ex.printStackTrace();
470                        throw ex;
471                }
472                       
473                ArrayList<ClassLink> solCLs = new ArrayList<ClassLink>();
474                for (; results.hasNext();) {
475                        QuerySolution sol = results.next();
476                        Resource pro = sol.getResource("p");
477                        if (pro != null) {
478                                Resource cls = sol.getResource("c");
479                                Resource dir = sol.getResource("pDirection");
480                                String proURI = pro.getURI();
481                                String clsURI = cls.getURI();
482                                String dirURI = dir.getURI();
483
484                                // System.out.println(pro.getURI() + " " + cls.getURI() + " " +
485                                // dir.getURI());
486
487                                Direction direction = null;
488                                if (dirURI
489                                                .equals("http://www.w3.org/2000/01/rdf-schema#domain")
490                                                || dirURI.equals("rdfs:domain")) {
491                                        direction = Direction.reverse;
492                                }
493                                if (dirURI.equals("http://www.w3.org/2000/01/rdf-schema#range")
494                                                || dirURI.equals("rdfs:range")) {
495                                        if (direction != null) {
496                                                direction = Direction.both;
497                                        } else {
498                                                direction = Direction.forward;
499                                        }
500                                }
501                                // System.out.println(direction);
502                                int numOfLinks = 0;
503                                if (countLinks) {
504                                        numOfLinks = sol.getLiteral("numOfLinks").getInt();
505                                }
506                                ClassLink cl = new ClassLink(proURI, clsURI, direction,
507                                                numOfLinks, 0, 0, 0, 0 );
508                                solCLs.add(cl);
509                        }
510                }
511                qexec.close();
512                return solCLs.toArray(new ClassLink[0]);
513        }
514
515        /**
516         * 縲€謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€√◎縺ｮ繧ｯ繝ｩ繧ｹ縺ｫ螻槭＠縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励＠縲�
517         * 蜿門ｾ励＠縺溘う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
518         * <p>
519         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
520         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
521         * </p>
522         *
523         * @param graphURIs
524         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
525         * @param originClass
526         *            襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲€��ull荳榊庄��
527         * @param limit
528         *            隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
529         * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
530         * @throws Exception
531         * @since 28.01.2014
532         */
533        public ClassLink[] getNextClassViaInstanceLink(String[] graphURIs,
534                        String originClass, int limit) throws Exception {
535                StringBuffer queryStr = new StringBuffer();
536                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
537                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
538                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
539                queryStr.append("SELECT DISTINCT ?pf ?pr (COUNT(?pf) AS ?numOfForwardLinks) (COUNT(?pr) AS ?numOfReverseLinks) (COUNT(DISTINCT(?insOrg)) AS ?numOfOriginInstances) (COUNT(DISTINCT(?ins)) AS ?numOfLinkedInstances)  ?c \n");
540                if (graphURIs != null) {
541                        for (String graphURI : graphURIs) {
542                                queryStr.append("FROM <");
543                                queryStr.append(graphURI);
544                                queryStr.append(">\n");
545                        }
546                }
547                queryStr.append("WHERE{\n");
548                queryStr.append("  ?ins rdf:type ?c.\n");
549                queryStr.append("  ?insOrg rdf:type <");
550                queryStr.append(originClass);
551                queryStr.append(">.\n");
552                queryStr.append("  { ?ins ?pr ?insOrg. }\n  UNION { ?insOrg ?pf ?ins. }\n");
553                queryStr.append("}\n");
554                queryStr.append("GROUP BY ?pf ?pr ?c\n");
555                if (limit > 0) {
556                        queryStr.append("limit ");
557                        queryStr.append(limit);
558                        queryStr.append("\n");
559                }
560
561System.out.println(queryStr.toString());
562
563                Query query = QueryFactory.create(queryStr.toString());
564                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
565                                query);
566
567                ResultSet results = null;
568                try{
569                        long start = System.currentTimeMillis();
570                        results = qexec.execSelect();
571                        long end = System.currentTimeMillis();
572                        System.out.println("EXEC TIME: " + (end-start));
573                }catch(Exception ex){
574                        ex.printStackTrace();
575                        throw ex;
576                }
577
578                ArrayList<ClassLink> solCLs = new ArrayList<ClassLink>();
579                for (; results.hasNext();) {
580                        QuerySolution sol = results.next();
581                        Resource proForward = sol.getResource("pf");
582                        Resource proReverse = sol.getResource("pr");
583                        Resource cls = sol.getResource("c");
584                        Direction direction = null;
585                        String propURI = null;
586                        int numOfLinks = 0;
587                        int numOfLinkedInstances = 0;
588                        int numOfOriginInstances = 0;
589                        if (proForward != null) {
590                                if (proReverse != null) {
591                                        numOfLinks = sol.getLiteral("numOfForwardLinks").getInt();
592                                        numOfLinks += sol.getLiteral("numOfReverseLinks").getInt();
593                                        numOfLinkedInstances = sol.getLiteral("numOfLinkedInstances").getInt();
594                                        numOfOriginInstances = sol.getLiteral("numOfOriginInstances").getInt();
595                                        direction = Direction.both;
596                                } else {
597                                        numOfLinkedInstances = sol.getLiteral("numOfLinkedInstances").getInt();
598                                        numOfOriginInstances = sol.getLiteral("numOfOriginInstances").getInt();
599                                        numOfLinks = sol.getLiteral("numOfForwardLinks").getInt();
600                                        direction = Direction.forward;
601                                }
602                                propURI = proForward.getURI();
603                        } else {
604                                direction = Direction.reverse;
605                                propURI = proReverse.getURI();
606                                numOfLinkedInstances = sol.getLiteral("numOfOriginInstances").getInt();
607                                numOfOriginInstances = sol.getLiteral("numOfLinkedInstances").getInt();
608                                numOfLinks = sol.getLiteral("numOfReverseLinks").getInt();
609                        }
610                        String clsURI = cls.getURI();
611                        // System.out.println(propURI + " " + clsURI + " " + direction);
612
613                        ClassLink cl = new ClassLink(propURI, clsURI, direction, numOfLinks, numOfOriginInstances, numOfLinkedInstances, 0, 0);
614                        solCLs.add(cl);
615                }
616                qexec.close();
617                return solCLs.toArray(new ClassLink[0]);
618        }
619
620        public Path[] getPaths(String startClass, String endClass, int mode,
621                        boolean countLinks) throws Exception {
622                OWLClassGraph graph = new OWLClassGraph(startClass, endClass);
623                return graph.getPaths(this, mode, countLinks);
624        }
625
626        public String createSPARQL(Path path) throws Exception {
627                return null;
628        }
629
630        /*
631         * private String executeSelect(String sparqlQuery) throws Exception {
632         * HttpClient client = HttpClientBuilder.create().build(); HttpPost httppost
633         * = new HttpPost(endpointURI); httppost.setHeader("Content-Type",
634         * "application/x-www-form-urlencoded"); httppost.setHeader("Accept",
635         * "application/sparql-results+xml"); List<NameValuePair> nvpList = new
636         * ArrayList<NameValuePair>(); nvpList.add(new BasicNameValuePair("query",
637         * sparqlQuery)); // nvpList.add(new BasicNameValuePair("format", //
638         * outputFormat.getMime())); httppost.setEntity(new
639         * UrlEncodedFormEntity(nvpList, Charset .forName("UTF-8"))); HttpResponse
640         * response = client.execute(httppost); //
641         * System.out.println("[StatusLine] " + response.getStatusLine());
642         * HttpEntity entity = response.getEntity(); String entityString =
643         * EntityUtils.toString(entity, "UTF-8"); return entityString; }
644         */
645
646        /**
647         * 縲€謖�ｮ壹＆繧後◆繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€√◎縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｫ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励☆繧九€�
648         * 縲€蜿門ｾ励＆繧後◆蜷�う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧らｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
649         * <p>
650         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
651         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
652         * </p>
653         *
654         * @param graphURIs
655         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
656         * @param originInstance
657         *            襍ｷ轤ｹ縺ｨ縺ｪ繧九う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI縲€��ull荳榊庄��
658         * @param limit
659         *            隗｣縺ｨ縺励※霑斐＆繧後ｋInstanceLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
660         * @return InstanceLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
661         * @throws Exception
662         * @since 28.01.2014
663         */
664        public InstanceLink[] getNextInstancesViaInstanceLink(String[] graphURIs,
665                        String originInstance, int limit) throws Exception {
666                StringBuffer queryStr = new StringBuffer();
667                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
668                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
669                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
670                queryStr.append("SELECT DISTINCT ?pf ?pr ?ins ?c \n");
671                if (graphURIs != null) {
672                        for (String graphURI : graphURIs) {
673                                queryStr.append("FROM <");
674                                queryStr.append(graphURI);
675                                queryStr.append(">\n");
676                        }
677                }
678                queryStr.append("WHERE{\n");
679                // queryStr.append("  { ?c rdf:type rdfs:Class. }\n  UNION\n  { ?c rdf:type owl:Class. }\n");
680                queryStr.append("  ?ins rdf:type ?c.\n");
681                queryStr.append("  { ?ins ?pr <");
682                queryStr.append(originInstance);
683                queryStr.append(">. }\n  UNION { <");
684                queryStr.append(originInstance);
685                queryStr.append("> ?pf ?ins. }\n");
686
687                queryStr.append(" FILTER (?c != rdf:Property)");
688
689                queryStr.append("}\n");
690                if (limit > 0) {
691                        queryStr.append("limit ");
692                        queryStr.append(limit);
693                        queryStr.append("\n");
694                }
695
696                // System.out.println(queryStr.toString());
697
698                Query query = QueryFactory.create(queryStr.toString());
699                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
700                                query);
701
702                ResultSet results = qexec.execSelect();
703                HashMap<String, InstanceLink> insLinkMap = new HashMap<String, InstanceLink>();
704                for (; results.hasNext();) {
705                        QuerySolution sol = results.next();
706                        Resource proForward = sol.getResource("pf");
707                        Resource proReverse = sol.getResource("pr");
708                        Resource ins = sol.getResource("ins");
709                        Resource cls = sol.getResource("c");
710                        Direction direction = null;
711                        String propURI = null;
712                        if (proForward != null) {
713                                if (proReverse != null) {
714                                        direction = Direction.both;
715                                } else {
716                                        direction = Direction.forward;
717                                }
718                                propURI = proForward.getURI();
719                        } else {
720                                direction = Direction.reverse;
721                                propURI = proReverse.getURI();
722                        }
723                        String clsURI = cls.getURI();
724                        String insURI = ins.getURI();
725                        String key = propURI + "\t" + insURI + "\t" + direction;
726                        if (insLinkMap.containsKey(key)) {
727                                InstanceLink insLink = insLinkMap.get(key);
728                                insLink.addLinkedClassURI(clsURI);
729                        } else {
730                                InstanceLink insLink = new InstanceLink(propURI, insURI,
731                                                new String[] { clsURI }, direction);
732                                insLinkMap.put(key, insLink);
733                        }
734                }
735                qexec.close();
736                Collection<InstanceLink> values = insLinkMap.values();
737                return values.toArray(new InstanceLink[0]);
738        }
739
740        public LabelMap[] getLabels(String[] graphURIs, String[] resourceURIs,
741                        String language) throws Exception {
742                if (resourceURIs == null || resourceURIs.length == 0) {
743                        return new LabelMap[0];
744                }
745                StringBuffer queryStr = new StringBuffer();
746                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
747                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
748                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
749                queryStr.append("SELECT DISTINCT ?res ?label \n");
750                if (graphURIs != null) {
751                        for (String graphURI : graphURIs) {
752                                queryStr.append("FROM <");
753                                queryStr.append(graphURI);
754                                queryStr.append(">\n");
755                        }
756                }
757                queryStr.append("WHERE{\n");
758                queryStr.append("  ?res rdfs:label ?label.\n");
759                queryStr.append("  FILTER(?res IN (");
760                boolean f = false;
761                for (String resourceURI : resourceURIs) {
762                        if (f) {
763                                queryStr.append(", ");
764                        }
765                        f = true;
766                        queryStr.append("<");
767                        queryStr.append(resourceURI);
768                        queryStr.append(">");
769                }
770                queryStr.append("))\n");
771                queryStr.append("}");
772
773                System.out.println(queryStr.toString());
774
775                Query query = QueryFactory.create(queryStr.toString());
776                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
777                                query);
778
779                ResultSet results = qexec.execSelect();
780                HashMap<String, LabelMap> lMap = new HashMap<String, LabelMap>();
781                for (; results.hasNext();) {
782                        QuerySolution sol = results.next();
783                        String uri = sol.getResource("res").getURI();
784                        Literal literal = sol.getLiteral("label");
785                        if (literal != null) {
786                                String label = literal.getString();
787                                String lang = literal.getLanguage();
788                                if (language != null && language.equals(lang)) {
789                                        Label lbl = new Label(label, lang);
790                                        if (lMap.containsKey(uri)) {
791                                                LabelMap lm = lMap.get(uri);
792                                                lm.addLabel(lbl);
793                                        } else {
794                                                LabelMap lm = new LabelMap(uri, new Label[] { lbl });
795                                                lMap.put(uri, lm);
796                                        }
797                                }
798                        }
799                }
800                return lMap.values().toArray(new LabelMap[0]);
801        }
802
803        public ClassLink[] countLinks(String[] graphURIs, String startClassURI,
804                        ClassLink[] classLinks) throws Exception {
805                if (classLinks == null || classLinks.length == 0) {
806                        return new ClassLink[0];
807                }
808                for (ClassLink classLink : classLinks) {
809                        StringBuffer queryStr = new StringBuffer();
810                        queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
811                        queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
812                        queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
813
814                        queryStr.append("SELECT (COUNT(?os) AS ?numOfLinks) (COUNT(DISTINCT(?is)) AS ?numOfOriginInstances) (COUNT(DISTINCT(?os)) AS ?numOfLinkedInstances) \n");
815                        if (graphURIs != null) {
816                                for (String graphURI : graphURIs) {
817                                        queryStr.append("FROM <");
818                                        queryStr.append(graphURI);
819                                        queryStr.append(">\n");
820                                }
821                        }
822
823                        queryStr.append("WHERE{\n");
824                        if (classLink.getDirection() == Direction.forward) {
825                                queryStr.append("?is rdf:type  <");
826                                queryStr.append(startClassURI);
827                                queryStr.append(">.\n");
828                                queryStr.append("?os rdf:type  <");
829                                queryStr.append(classLink.getLinkedClassURI());
830                                queryStr.append(">.\n");
831                                queryStr.append("?is <");
832                                queryStr.append(classLink.getPropertyURI());
833                                queryStr.append("> ?os.\n");
834                                queryStr.append("}");
835                        } else {
836                                if (classLink.getDirection() == Direction.forward) {
837                                        queryStr.append("?os rdf:type  <");
838                                        queryStr.append(startClassURI);
839                                        queryStr.append(">.\n");
840                                        queryStr.append("?is rdf:type  <");
841                                        queryStr.append(classLink.getLinkedClassURI());
842                                        queryStr.append(">.\n");
843                                        queryStr.append("?is <");
844                                        queryStr.append(classLink.getPropertyURI());
845                                        queryStr.append("> ?os.\n");
846                                        queryStr.append("}");
847                                } else {
848                                        queryStr.append("?os rdf:type  <");
849                                        queryStr.append(startClassURI);
850                                        queryStr.append(">.\n");
851                                        queryStr.append("?is rdf:type  <");
852                                        queryStr.append(classLink.getLinkedClassURI());
853                                        queryStr.append(">.\n");
854                                        queryStr.append("{?is <");
855                                        queryStr.append(classLink.getPropertyURI());
856                                        queryStr.append("> ?os.}\n");
857                                        queryStr.append("UNION\n");
858                                        queryStr.append("{?os <");
859                                        queryStr.append(classLink.getPropertyURI());
860                                        queryStr.append("> ?is.}\n");
861                                        queryStr.append("}");
862                                }
863                        }
864                        System.out.println(queryStr.toString());
865
866                        Query query = QueryFactory.create(queryStr.toString());
867                        QueryExecution qexec = QueryExecutionFactory.sparqlService(
868                                        endpointURI, query);
869
870                        ResultSet results = qexec.execSelect();
871                        if (results.hasNext()) {
872                                QuerySolution sol = results.next();
873                                Literal lit = sol.getLiteral("numOfLinks");
874                                if (lit != null) {
875                                        int numOfLinks = lit.getInt();
876                                        classLink.setNumOfLinks(numOfLinks);
877                                }
878                                lit = sol.getLiteral("numOfLinkedInstances");
879                                if (lit != null) {
880                                        int numOfLinkedInstances = lit.getInt();
881                                        classLink.setNumOfLinkedInstances(numOfLinkedInstances);
882                                }
883                                lit = sol.getLiteral("numOfOriginInstances");
884                                if (lit != null) {
885                                        int numOfOriginInstances = lit.getInt();
886                                        classLink.setNumOfOriginInstances(numOfOriginInstances);
887                                }
888                                lit = sol.getLiteral("numOfOriginClassInstances");
889                                if (lit != null) {
890                                        int numOfOriginClassInstances = lit.getInt();
891                                        classLink.setNumOfOriginClassInstances(numOfOriginClassInstances);
892                                }
893                                lit = sol.getLiteral("numOfLinkedClassInstances");
894                                if (lit != null) {
895                                        int numOfLinkedClassInstances = lit.getInt();
896                                        classLink.setNumOfLinkedClassInstances(numOfLinkedClassInstances);
897                                }
898                        }
899                        qexec.close();
900
901                        // count instances
902                        queryStr = new StringBuffer();
903                        queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
904                        queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
905                        queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
906
907                        queryStr.append("SELECT (COUNT(?ics) AS ?numOfOriginClassInstances) \n");
908                        if (graphURIs != null) {
909                                for (String graphURI : graphURIs) {
910                                        queryStr.append("FROM <");
911                                        queryStr.append(graphURI);
912                                        queryStr.append(">\n");
913                                }
914                        }
915
916                        queryStr.append("WHERE{\n");
917                        if (classLink.getDirection() == Direction.forward) {
918                                queryStr.append("?ics rdf:type  <");
919                                queryStr.append(startClassURI);
920                                queryStr.append(">.\n");
921                                queryStr.append("}");
922                        } else {
923                                if (classLink.getDirection() == Direction.forward) {
924                                        queryStr.append("?ics rdf:type  <");
925                                        queryStr.append(classLink.getLinkedClassURI());
926                                        queryStr.append(">.\n");
927                                        queryStr.append("}");
928                                } else {
929                                        queryStr.append("?ics rdf:type  <");
930                                        queryStr.append(classLink.getLinkedClassURI());
931                                        queryStr.append(">.\n");
932                                        queryStr.append("}");
933                                }
934                        }
935       
936                        System.out.println(queryStr.toString());
937
938                        query = QueryFactory.create(queryStr.toString());
939                        qexec = QueryExecutionFactory.sparqlService(
940                                        endpointURI, query);
941
942                        results = qexec.execSelect();
943                        if (results.hasNext()) {
944                                QuerySolution sol = results.next();
945                                Literal lit = null;
946                                lit = sol.getLiteral("numOfOriginClassInstances");
947                                if (lit != null) {
948                                        int numOfOriginClassInstances = lit.getInt();
949                                        classLink.setNumOfOriginClassInstances(numOfOriginClassInstances);
950                                }
951                        }
952                        qexec.close();
953
954                        // count instances
955                        queryStr = new StringBuffer();
956                        queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
957                        queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
958                        queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
959
960                        queryStr.append("SELECT (COUNT(?ocs) AS ?numOfLinkedClassInstances) \n");
961                        if (graphURIs != null) {
962                                for (String graphURI : graphURIs) {
963                                        queryStr.append("FROM <");
964                                        queryStr.append(graphURI);
965                                        queryStr.append(">\n");
966                                }
967                        }
968
969                        queryStr.append("WHERE{\n");
970                        if (classLink.getDirection() == Direction.forward) {
971                                queryStr.append("?ocs rdf:type  <");
972                                queryStr.append(classLink.getLinkedClassURI());
973                                queryStr.append(">.\n");
974                                queryStr.append("}");
975                        } else {
976                                if (classLink.getDirection() == Direction.forward) {
977                                        queryStr.append("?ocs rdf:type  <");
978                                        queryStr.append(startClassURI);
979                                        queryStr.append(">.\n");
980                                        queryStr.append("}");
981                                } else {
982                                        queryStr.append("?ocs rdf:type  <");
983                                        queryStr.append(startClassURI);
984                                        queryStr.append(">.\n");
985                                        queryStr.append("}");
986                                }
987                        }
988       
989                        System.out.println(queryStr.toString());
990
991                        query = QueryFactory.create(queryStr.toString());
992                        qexec = QueryExecutionFactory.sparqlService(
993                                        endpointURI, query);
994
995                        results = qexec.execSelect();
996                        if (results.hasNext()) {
997                                QuerySolution sol = results.next();
998                                Literal lit = null;
999                                lit = sol.getLiteral("numOfLinkedClassInstances");
1000                                if (lit != null) {
1001                                        int numOfLinkedClassInstances = lit.getInt();
1002                                        classLink.setNumOfLinkedClassInstances(numOfLinkedClassInstances);
1003                                }
1004                        }
1005                        qexec.close();
1006                       
1007                }
1008                return classLinks;
1009        }
1010
1011       
1012        public SClass[] countInstances(String[] graphURIs, SClass[] classes)
1013                        throws Exception {
1014                if (classes == null || classes.length == 0) {
1015                        return new SClass[0];
1016                }
1017                HashMap<String, SClass> classMap = new HashMap<String, SClass>();
1018                for (SClass sc : classes) {
1019                        classMap.put(sc.getClassURI(), sc);
1020                }
1021                StringBuffer queryStr = new StringBuffer();
1022                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
1023                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
1024                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
1025                queryStr.append("SELECT DISTINCT ?cls  (COUNT(?is) AS ?numOfInstances)\n");
1026                if (graphURIs != null) {
1027                        for (String graphURI : graphURIs) {
1028                                queryStr.append("FROM <");
1029                                queryStr.append(graphURI);
1030                                queryStr.append(">\n");
1031                        }
1032                }
1033                queryStr.append("WHERE{\n");
1034                queryStr.append("  ?is rdf:type ?cls.\n");
1035                queryStr.append("  FILTER(?cls IN (");
1036                boolean f = false;
1037                Set<String> clsSet = classMap.keySet();
1038                for (String clsURI : clsSet) {
1039                        if (f) {
1040                                queryStr.append(", ");
1041                        }
1042                        f = true;
1043                        queryStr.append("<");
1044                        queryStr.append(clsURI);
1045                        queryStr.append(">");
1046                }
1047                queryStr.append("))\n");
1048                queryStr.append("} GROUP BY ?cls");
1049
1050                System.out.println(queryStr.toString());
1051
1052                Query query = QueryFactory.create(queryStr.toString());
1053                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
1054                                query);
1055
1056                ResultSet results = qexec.execSelect();
1057                for (; results.hasNext();) {
1058                        QuerySolution sol = results.next();
1059                        String uri = sol.getResource("cls").getURI();
1060                        SClass sc = classMap.get(uri);
1061                        Literal lit = sol.getLiteral("numOfInstances");
1062                        if (lit != null) {
1063                                int numOfInstances = lit.getInt();
1064                                sc.setNumOfInstances(numOfInstances);
1065                        }
1066                }
1067                qexec.close();
1068
1069                return classes;
1070        }
1071
1072}
Note: リポジトリブラウザについてのヘルプは TracBrowser を参照してください。