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

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

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