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

リビジョン 49, 35.0 KB (コミッタ: nori, 11 年 前)

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