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

リビジョン 32, 27.6 KB (コミッタ: atsuko, 11 年 前)

getPath の引数変更
  • 属性 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 {
[26]54                String sparqlEndpoint = "http://dbpedia.org/sparql";
[28]55                // String sparqlEndpoint = "http://lsd.dbcls.jp/sparql";
[26]56                String keyword = "artiste";
[28]57                // String keyword = "Agent";
[2]58                String[] graphURIs = new String[0];
59
60                OWLQueryBuilder builder = new OWLQueryBuilderImpl(sparqlEndpoint);
[28]61                SClass[] clz = builder.getOWLClasses(graphURIs, keyword, false);
[22]62                for (SClass cls : clz) {
[2]63                        System.out.println(cls);
64                }
[31]65                clz = builder.countInstances(null, clz);
66                for (SClass cls : clz) {
67                        System.out.println(cls);
68                }
69               
[2]70
[31]71/*
72                System.out.println("CLS");
73 
[26]74                ClassLink[] cls = builder.getNextClass(null, clz[1].getClassURI(), 100,
75                                false);
76                if (cls != null) {
77                        for (ClassLink cl : cls) {
78                                System.out.println(cl.toString());
79                        }
80                        cls = builder.countLinks(null, clz[1].getClassURI(), cls);
81                        for (ClassLink cl : cls) {
82                                System.out.println(cl.toString());
83                        }
84                }
[31]85*/
[22]86                /*
87                 * System.out.println("CLS-INS"); cls =
88                 * builder.getNextClassViaInstanceLink(null, clz[0].getClassURI(), 100);
89                 * if( cls != null ){ for( ClassLink cl: cls){
90                 * System.out.println(cl.toString()); } }
91                 *
92                 * System.out.println("Instances"); Instance[] ins =
93                 * builder.getInstances(null, "\"A.C. Reed\"@en"); if( ins != null ){
94                 * for( Instance in: ins){ System.out.println(in.toString()); } }
95                 *
96                 *
97                 * System.out.println("INS-INS"); ins = builder.getInstances(null,
98                 * "\"A.C. Reed\"@en"); InstanceLink[] iLinks =
99                 * builder.getNextInstancesViaInstanceLink(null,
100                 * ins[0].getInstanceURI(), 100);
101                 *
102                 *
103                 *
104                 * if( iLinks != null ){ for( InstanceLink in: iLinks){
105                 * System.out.println(in.toString()); } }
106                 */
[2]107        }
108
109        /**
110         * 譏守､ｺ逧�↓RDF縺ｧ譖ｸ縺九ｌ縺ｦ縺�ｋ繧ｯ繝ｩ繧ｹ繧貞叙蠕励☆繧�
111         * <p>
[22]112         * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧ｯ繝ｩ繧ｹ��dfs:Class�峨ｒ縺吶∋縺ｦ霑斐☆ <br>
[2]113         * </p>
114         *
[22]115         * @param graphURIs
116         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� (null繧�聞縺�縺ｮ驟榊�繧ょ庄)
117         * @param keyword
118         *            ��ull繧�ｩｺ譁�ｭ励�荳榊庄��
[2]119         * @return 繧ｯ繝ｩ繧ｹURI縺ｮ驟榊�
120         * @throws Exception
121         * @since 28.01.2014
122         */
[28]123        public SClass[] getOWLClasses(String[] graphURIs, String keyword,
124                        boolean countInstances) throws Exception {
[2]125                StringBuffer queryStr = new StringBuffer();
126                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
127                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
128                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
[28]129                if (countInstances) {
130                        queryStr.append("SELECT DISTINCT ?c ?pLabel (COUNT(?i) AS ?numOfInstances)\n");
131                } else {
132                        queryStr.append("SELECT DISTINCT ?c ?pLabel \n");
133                }
[2]134                if (graphURIs != null) {
135                        for (String graphURI : graphURIs) {
136                                queryStr.append("FROM <");
137                                queryStr.append(graphURI);
138                                queryStr.append(">\n");
139                        }
140                }
141                queryStr.append("WHERE{\n");
[22]142
[2]143                queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n");
144
145                queryStr.append("      ?c rdfs:label ?label.\n");
[10]146                queryStr.append("      ?c rdfs:label ?pLabel.\n");
[28]147                if (countInstances) {
148                        queryStr.append("      ?i rdf:type ?c.\n");
149                }
[22]150                // queryStr.append("      ?c rdfs:label ");
151                // queryStr.append(keyword);
152                // queryStr.append(".");
[28]153                if (keyword != null && keyword.length() != 0) {
154                        queryStr.append("  FILTER (\n");
155                        queryStr.append("    REGEX( ?label , \"");
156                        queryStr.append(keyword);
157                        queryStr.append("\" , \"i\" )\n");
158                        queryStr.append("  )");
159                }
160                if (countInstances) {
161                        queryStr.append("\n}  GROUP BY ?c ?pLabel");
162                } else {
163                        queryStr.append("\n}");
164                }
[22]165                System.out.println(queryStr.toString());
166
[2]167                Query query = QueryFactory.create(queryStr.toString());
168                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
169                                query);
170
171                ResultSet results = qexec.execSelect();
[22]172                HashMap<String, SClass> classMap = new HashMap<String, SClass>();
[2]173                for (; results.hasNext();) {
174                        QuerySolution sol = results.next();
175                        Resource res = sol.getResource("c");
[22]176                        if (res != null) {
177                                String uri = res.getURI();
[31]178                                int numOfInstances = 0;
179                                if( countInstances ){
180                                        numOfInstances = sol.getLiteral("numOfInstances").getInt();
181                                }
[22]182                                // System.out.println(numOfInstances);
183                                Literal labelLiteral = sol.getLiteral("pLabel");
184                                SClass sClass = null;
185                                if (classMap.containsKey(uri)) {
186                                        sClass = classMap.get(uri);
187                                } else {
[10]188                                        sClass = new SClass(uri, null, numOfInstances);
189                                        classMap.put(uri, sClass);
[22]190                                }
191                                if (labelLiteral != null) {
[10]192                                        String label = labelLiteral.getString();
193                                        String lang = labelLiteral.getLanguage();
194                                        sClass.addLabel(new Label(label, lang));
195                                }
[22]196                        }
[2]197                }
198                qexec.close();
[10]199                return classMap.values().toArray(new SClass[0]);
[2]200        }
201
202        /**
[22]203         * 縲€繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧貞叙蠕励☆繧�
[2]204         * <p>
[22]205         * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧偵☆縺ｹ縺ｦ霑斐☆ <br>
206         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
[2]207         * </p>
208         *
[22]209         * @param graphURIs
210         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� (null繧�聞縺�縺ｮ驟榊�繧ょ庄)
211         * @param keyword
212         *            ��ull繧�ｩｺ譁�ｭ励�荳榊庄��
[2]213         * @return 繧ｯ繝ｩ繧ｹURI縺ｮ驟榊�
214         * @throws Exception
215         * @since 28.01.2014
216         */
217        public Instance[] getInstances(String[] graphURIs, String keyword)
218                        throws Exception {
219                StringBuffer queryStr = new StringBuffer();
220                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
221                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
222                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
223                queryStr.append("SELECT DISTINCT ?ins ?c \n");
224                if (graphURIs != null) {
225                        for (String graphURI : graphURIs) {
226                                queryStr.append("FROM <");
227                                queryStr.append(graphURI);
228                                queryStr.append(">\n");
229                        }
230                }
231                queryStr.append("WHERE{\n");
[22]232                // queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n");
[2]233
234                queryStr.append("      ?ins rdf:type ?c.\n");
235                queryStr.append("      ?ins rdfs:label ");
236                queryStr.append(keyword);
237                queryStr.append(".\n");
238                queryStr.append(" FILTER (?c != rdf:Property)");
239                queryStr.append("}");
[22]240
241                // System.out.println(queryStr.toString());
242
[2]243                Query query = QueryFactory.create(queryStr.toString());
244                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
245                                query);
246
247                ResultSet results = qexec.execSelect();
248                HashMap<String, HashSet<String>> instanceMap = new HashMap<String, HashSet<String>>();
249                for (; results.hasNext();) {
250                        QuerySolution sol = results.next();
251                        Resource cls = sol.getResource("c");
252                        Resource ins = sol.getResource("ins");
253                        String clsURI = cls.getURI();
254                        String insURI = ins.getURI();
[22]255                        if (instanceMap.containsKey(insURI)) {
[2]256                                HashSet<String> classes = instanceMap.get(insURI);
257                                classes.add(clsURI);
[22]258                        } else {
[2]259                                HashSet<String> classes = new HashSet<String>();
260                                instanceMap.put(insURI, classes);
261                                classes.add(clsURI);
262                        }
263                }
264                qexec.close();
265                Set<String> keySet = instanceMap.keySet();
266                ArrayList<Instance> instanceList = new ArrayList<Instance>();
[22]267                for (String key : keySet) {
268                        Instance ins = new Instance(key, instanceMap.get(key).toArray(
269                                        new String[0]));
[2]270                        instanceList.add(ins);
271                }
272                return instanceList.toArray(new Instance[0]);
273        }
274
275        /**
[22]276         * 縲€謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€∵�遉ｺ逧�↓險倩ｿｰ縺輔ｌ縺ｦ縺�ｋOWL縺ｮproperty蛻ｶ邏�ｒ隱ｿ縺ｹ縲√◎縺ｮproperty蛻ｶ邏�〒
[2]277         * 髢｢騾｣縺･縺代ｉ繧後※縺�ｋ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
278         * <p>
[22]279         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
[2]280         * <br>
281         * </p>
282         *
[22]283         * @param graphURIs
284         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
285         * @param originClass
286         *            襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲€��ull荳榊庄��
287         * @param limit
288         *            隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
[2]289         * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
290         * @throws Exception
291         * @since 28.01.2014
292         */
293        public ClassLink[] getNextClass(String[] graphURIs, String originClass,
[20]294                        int limit, boolean countLinks) throws Exception {
[2]295                StringBuffer queryStr = new StringBuffer();
296                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
297                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
298                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
[20]299
300                // SELECT
[22]301                if (countLinks) {
302                        queryStr.append("SELECT DISTINCT ?p ?pDirection ?c (COUNT(?s) AS ?numOfLinks) \n");
303                } else {
[20]304                        queryStr.append("SELECT DISTINCT ?p ?pDirection ?c \n");
305                }
[22]306
[2]307                if (graphURIs != null) {
308                        for (String graphURI : graphURIs) {
309                                queryStr.append("FROM <");
310                                queryStr.append(graphURI);
311                                queryStr.append(">\n");
312                        }
313                }
314                queryStr.append("WHERE{\n");
[28]315                // queryStr.append("  { ?c rdf:type rdfs:Class. }\n  UNION\n  { ?c rdf:type owl:Class. }\n");
[2]316                queryStr.append("  { ?p rdfs:domain <");
317                queryStr.append(originClass);
[19]318                queryStr.append(">.\n    ?p rdfs:range ?c.\n");
[27]319
[22]320                if (countLinks) {
321                        queryStr.append("    ?o ?p ?s.");
[28]322                } else {
[27]323                        queryStr.append("filter(exists{\n");
324                        queryStr.append("  ?o rdf:type ?c.\n");
325                        queryStr.append(" ?s rdf:type <");
326                        queryStr.append(originClass);
327                        queryStr.append(">.\n");
328                        queryStr.append("       ?s ?p ?o.})\n");
[20]329                }
[22]330
[19]331                queryStr.append("}\n  UNION\n");
[2]332                queryStr.append("  { ?p rdfs:range <");
333                queryStr.append(originClass);
[5]334                queryStr.append(">.\n");
335                queryStr.append("    ?p rdfs:domain ?c.\n");
[20]336
[22]337                if (countLinks) {
338                        queryStr.append("    ?s ?p ?o.");
[28]339                } else {
[27]340                        queryStr.append("filter(exists{\n");
341                        queryStr.append("  ?s rdf:type ?c.\n");
342                        queryStr.append(" ?o rdf:type <");
343                        queryStr.append(originClass);
344                        queryStr.append(">.\n");
345                        queryStr.append("       ?s ?p ?o.})\n");
[20]346                }
[22]347
[19]348                queryStr.append("}\n");
[5]349
350                queryStr.append("    ?p ?pDirection ?c.\n");
351
352                queryStr.append("  ?s rdf:type ?c.\n");
[20]353
[22]354                if (countLinks) {
[20]355                        queryStr.append("}\nGROUP BY ?p ?pDirection ?c\n");
[22]356                } else {
[20]357                        queryStr.append("}\n");
358                }
[2]359                if (limit > 0) {
360                        queryStr.append("limit ");
361                        queryStr.append(limit);
362                        queryStr.append("\n");
363                }
[22]364
365                System.out.println(queryStr.toString());
366
[2]367                Query query = QueryFactory.create(queryStr.toString());
368                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
369                                query);
370
371                ResultSet results = qexec.execSelect();
372                ArrayList<ClassLink> solCLs = new ArrayList<ClassLink>();
373                for (; results.hasNext();) {
374                        QuerySolution sol = results.next();
375                        Resource pro = sol.getResource("p");
[22]376                        if (pro != null) {
377                                Resource cls = sol.getResource("c");
378                                Resource dir = sol.getResource("pDirection");
379                                String proURI = pro.getURI();
380                                String clsURI = cls.getURI();
381                                String dirURI = dir.getURI();
[2]382
[22]383                                // System.out.println(pro.getURI() + " " + cls.getURI() + " " +
384                                // dir.getURI());
385
386                                Direction direction = null;
387                                if (dirURI
388                                                .equals("http://www.w3.org/2000/01/rdf-schema#domain")
389                                                || dirURI.equals("rdfs:domain")) {
390                                        direction = Direction.reverse;
[2]391                                }
[22]392                                if (dirURI.equals("http://www.w3.org/2000/01/rdf-schema#range")
393                                                || dirURI.equals("rdfs:range")) {
394                                        if (direction != null) {
395                                                direction = Direction.both;
396                                        } else {
397                                                direction = Direction.forward;
398                                        }
399                                }
400                                // System.out.println(direction);
[23]401                                int numOfLinks = 0;
[26]402                                if (countLinks) {
403                                        numOfLinks = sol.getLiteral("numOfLinks").getInt();
[23]404                                }
[22]405                                ClassLink cl = new ClassLink(proURI, clsURI, direction,
406                                                numOfLinks);
407                                solCLs.add(cl);
[2]408                        }
409                }
410                qexec.close();
411                return solCLs.toArray(new ClassLink[0]);
412        }
[22]413
[2]414        /**
[22]415         * 縲€謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€√◎縺ｮ繧ｯ繝ｩ繧ｹ縺ｫ螻槭＠縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励＠縲�
416         * 蜿門ｾ励＠縺溘う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
[2]417         * <p>
[22]418         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
419         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
[2]420         * </p>
421         *
[22]422         * @param graphURIs
423         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
424         * @param originClass
425         *            襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲€��ull荳榊庄��
426         * @param limit
427         *            隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
[2]428         * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
429         * @throws Exception
430         * @since 28.01.2014
431         */
[22]432        public ClassLink[] getNextClassViaInstanceLink(String[] graphURIs,
433                        String originClass, int limit) throws Exception {
[2]434                StringBuffer queryStr = new StringBuffer();
435                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
436                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
437                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
438                queryStr.append("SELECT DISTINCT ?pf ?pr ?c \n");
439                if (graphURIs != null) {
440                        for (String graphURI : graphURIs) {
441                                queryStr.append("FROM <");
442                                queryStr.append(graphURI);
443                                queryStr.append(">\n");
444                        }
445                }
446                queryStr.append("WHERE{\n");
447                queryStr.append("  ?ins rdf:type ?c.\n");
448                queryStr.append("  ?insOrg rdf:type <");
449                queryStr.append(originClass);
450                queryStr.append(">.\n");
451                queryStr.append("  { ?ins ?pr ?insOrg. }\n  UNION { ?insOrg ?pf ?ins. }\n");
452                queryStr.append("}\n");
453                if (limit > 0) {
454                        queryStr.append("limit ");
455                        queryStr.append(limit);
456                        queryStr.append("\n");
457                }
[22]458
459                // System.out.println(queryStr.toString());
460
[2]461                Query query = QueryFactory.create(queryStr.toString());
462                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
463                                query);
464
465                ResultSet results = qexec.execSelect();
466                ArrayList<ClassLink> solCLs = new ArrayList<ClassLink>();
467                for (; results.hasNext();) {
468                        QuerySolution sol = results.next();
469                        Resource proForward = sol.getResource("pf");
470                        Resource proReverse = sol.getResource("pr");
471                        Resource cls = sol.getResource("c");
472                        Direction direction = null;
473                        String propURI = null;
[22]474                        if (proForward != null) {
475                                if (proReverse != null) {
[2]476                                        direction = Direction.both;
[22]477                                } else {
[2]478                                        direction = Direction.forward;
479                                }
480                                propURI = proForward.getURI();
[22]481                        } else {
[2]482                                direction = Direction.reverse;
483                                propURI = proReverse.getURI();
484                        }
485                        String clsURI = cls.getURI();
[22]486                        // System.out.println(propURI + " " + clsURI + " " + direction);
487
[2]488                        ClassLink cl = new ClassLink(propURI, clsURI, direction, 0);
489                        solCLs.add(cl);
490                }
491                qexec.close();
492                return solCLs.toArray(new ClassLink[0]);
493        }
494
[32]495        public Path[] getPaths(String startClass, String endClass, int mode, boolean countLinks) throws Exception {
[2]496                OWLClassGraph graph = new OWLClassGraph(startClass, endClass);
[32]497                return graph.getPaths(this, mode, countLinks);
[2]498        }
499
500        public String createSPARQL(Path path) throws Exception {
501                return null;
502        }
503
[22]504        /*
505         * private String executeSelect(String sparqlQuery) throws Exception {
506         * HttpClient client = HttpClientBuilder.create().build(); HttpPost httppost
507         * = new HttpPost(endpointURI); httppost.setHeader("Content-Type",
508         * "application/x-www-form-urlencoded"); httppost.setHeader("Accept",
509         * "application/sparql-results+xml"); List<NameValuePair> nvpList = new
510         * ArrayList<NameValuePair>(); nvpList.add(new BasicNameValuePair("query",
511         * sparqlQuery)); // nvpList.add(new BasicNameValuePair("format", //
512         * outputFormat.getMime())); httppost.setEntity(new
513         * UrlEncodedFormEntity(nvpList, Charset .forName("UTF-8"))); HttpResponse
514         * response = client.execute(httppost); //
515         * System.out.println("[StatusLine] " + response.getStatusLine());
516         * HttpEntity entity = response.getEntity(); String entityString =
517         * EntityUtils.toString(entity, "UTF-8"); return entityString; }
518         */
[2]519
520        /**
[22]521         * 縲€謖�ｮ壹＆繧後◆繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励€√◎縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｫ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励☆繧九€�
522         * 縲€蜿門ｾ励＆繧後◆蜷�う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧らｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
[2]523         * <p>
[22]524         * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
525         * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
[2]526         * </p>
527         *
[22]528         * @param graphURIs
529         *            縲€讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲€(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
530         * @param originInstance
531         *            襍ｷ轤ｹ縺ｨ縺ｪ繧九う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI縲€��ull荳榊庄��
532         * @param limit
533         *            隗｣縺ｨ縺励※霑斐＆繧後ｋInstanceLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九€�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
[2]534         * @return InstanceLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
535         * @throws Exception
536         * @since 28.01.2014
537         */
[22]538        public InstanceLink[] getNextInstancesViaInstanceLink(String[] graphURIs,
539                        String originInstance, int limit) throws Exception {
[2]540                StringBuffer queryStr = new StringBuffer();
541                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
542                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
543                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
544                queryStr.append("SELECT DISTINCT ?pf ?pr ?ins ?c \n");
545                if (graphURIs != null) {
546                        for (String graphURI : graphURIs) {
547                                queryStr.append("FROM <");
548                                queryStr.append(graphURI);
549                                queryStr.append(">\n");
550                        }
551                }
552                queryStr.append("WHERE{\n");
[22]553                // queryStr.append("  { ?c rdf:type rdfs:Class. }\n  UNION\n  { ?c rdf:type owl:Class. }\n");
[2]554                queryStr.append("  ?ins rdf:type ?c.\n");
555                queryStr.append("  { ?ins ?pr <");
556                queryStr.append(originInstance);
557                queryStr.append(">. }\n  UNION { <");
558                queryStr.append(originInstance);
559                queryStr.append("> ?pf ?ins. }\n");
560
561                queryStr.append(" FILTER (?c != rdf:Property)");
562
563                queryStr.append("}\n");
564                if (limit > 0) {
565                        queryStr.append("limit ");
566                        queryStr.append(limit);
567                        queryStr.append("\n");
568                }
[22]569
570                // System.out.println(queryStr.toString());
571
[2]572                Query query = QueryFactory.create(queryStr.toString());
573                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
574                                query);
575
576                ResultSet results = qexec.execSelect();
577                HashMap<String, InstanceLink> insLinkMap = new HashMap<String, InstanceLink>();
578                for (; results.hasNext();) {
579                        QuerySolution sol = results.next();
580                        Resource proForward = sol.getResource("pf");
581                        Resource proReverse = sol.getResource("pr");
582                        Resource ins = sol.getResource("ins");
583                        Resource cls = sol.getResource("c");
584                        Direction direction = null;
585                        String propURI = null;
[22]586                        if (proForward != null) {
587                                if (proReverse != null) {
[2]588                                        direction = Direction.both;
[22]589                                } else {
[2]590                                        direction = Direction.forward;
591                                }
592                                propURI = proForward.getURI();
[22]593                        } else {
[2]594                                direction = Direction.reverse;
595                                propURI = proReverse.getURI();
596                        }
597                        String clsURI = cls.getURI();
598                        String insURI = ins.getURI();
599                        String key = propURI + "\t" + insURI + "\t" + direction;
[22]600                        if (insLinkMap.containsKey(key)) {
[2]601                                InstanceLink insLink = insLinkMap.get(key);
602                                insLink.addLinkedClassURI(clsURI);
[22]603                        } else {
604                                InstanceLink insLink = new InstanceLink(propURI, insURI,
605                                                new String[] { clsURI }, direction);
[2]606                                insLinkMap.put(key, insLink);
607                        }
608                }
609                qexec.close();
610                Collection<InstanceLink> values = insLinkMap.values();
611                return values.toArray(new InstanceLink[0]);
612        }
613
[22]614        public LabelMap[] getLabels(String[] graphURIs, String[] resourceURIs,
615                        String language) throws Exception {
616                if (resourceURIs == null || resourceURIs.length == 0) {
[19]617                        return new LabelMap[0];
618                }
619                StringBuffer queryStr = new StringBuffer();
620                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
621                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
622                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
623                queryStr.append("SELECT DISTINCT ?res ?label \n");
624                if (graphURIs != null) {
625                        for (String graphURI : graphURIs) {
626                                queryStr.append("FROM <");
627                                queryStr.append(graphURI);
628                                queryStr.append(">\n");
629                        }
630                }
631                queryStr.append("WHERE{\n");
632                queryStr.append("  ?res rdfs:label ?label.\n");
633                queryStr.append("  FILTER(?res IN (");
634                boolean f = false;
[22]635                for (String resourceURI : resourceURIs) {
636                        if (f) {
[19]637                                queryStr.append(", ");
638                        }
639                        f = true;
640                        queryStr.append("<");
641                        queryStr.append(resourceURI);
642                        queryStr.append(">");
643                }
644                queryStr.append("))\n");
645                queryStr.append("}");
[22]646
647                System.out.println(queryStr.toString());
648
[19]649                Query query = QueryFactory.create(queryStr.toString());
650                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
651                                query);
652
653                ResultSet results = qexec.execSelect();
654                HashMap<String, LabelMap> lMap = new HashMap<String, LabelMap>();
655                for (; results.hasNext();) {
656                        QuerySolution sol = results.next();
657                        String uri = sol.getResource("res").getURI();
658                        Literal literal = sol.getLiteral("label");
[22]659                        if (literal != null) {
[19]660                                String label = literal.getString();
661                                String lang = literal.getLanguage();
[22]662                                if (language != null && language.equals(lang)) {
[19]663                                        Label lbl = new Label(label, lang);
[22]664                                        if (lMap.containsKey(uri)) {
[19]665                                                LabelMap lm = lMap.get(uri);
666                                                lm.addLabel(lbl);
[22]667                                        } else {
668                                                LabelMap lm = new LabelMap(uri, new Label[] { lbl });
[19]669                                                lMap.put(uri, lm);
670                                        }
671                                }
672                        }
673                }
674                return lMap.values().toArray(new LabelMap[0]);
675        }
[22]676
[26]677        public ClassLink[] countLinks(String[] graphURIs, String startClassURI,
678                        ClassLink[] classLinks) throws Exception {
679                if (classLinks == null || classLinks.length == 0) {
680                        return new ClassLink[0];
681                }
682                for (ClassLink classLink : classLinks) {
683                        StringBuffer queryStr = new StringBuffer();
684                        queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
685                        queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
686                        queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
687
688                        queryStr.append("SELECT (COUNT(?os) AS ?numOfLinks) \n");
689                        if (graphURIs != null) {
690                                for (String graphURI : graphURIs) {
691                                        queryStr.append("FROM <");
692                                        queryStr.append(graphURI);
693                                        queryStr.append(">\n");
694                                }
695                        }
696
697                        queryStr.append("WHERE{\n");
698                        if (classLink.getDirection() == Direction.forward) {
699                                queryStr.append("?is rdf:type  <");
700                                queryStr.append(startClassURI);
701                                queryStr.append(">.\n");
702                                queryStr.append("?os rdf:type  <");
703                                queryStr.append(classLink.getLinkedClassURI());
704                                queryStr.append(">.\n");
705                                queryStr.append("?is ?p ?os.\n");
706                                queryStr.append("}");
707                        } else {
708                                if (classLink.getDirection() == Direction.forward) {
709                                        queryStr.append("?os rdf:type  <");
710                                        queryStr.append(startClassURI);
711                                        queryStr.append(">.\n");
712                                        queryStr.append("?is rdf:type  <");
713                                        queryStr.append(classLink.getLinkedClassURI());
714                                        queryStr.append(">.\n");
715                                        queryStr.append("?is ?p ?os.\n");
716                                        queryStr.append("}");
717                                } else {
718                                        queryStr.append("?os rdf:type  <");
719                                        queryStr.append(startClassURI);
720                                        queryStr.append(">.\n");
721                                        queryStr.append("?is rdf:type  <");
722                                        queryStr.append(classLink.getLinkedClassURI());
723                                        queryStr.append(">.\n");
724                                        queryStr.append("{?is ?p ?os.}\n");
725                                        queryStr.append("UNION\n");
726                                        queryStr.append("{?os ?p ?is.}\n");
727                                        queryStr.append("}");
728                                }
729                        }
730                        System.out.println(queryStr.toString());
731
732                        Query query = QueryFactory.create(queryStr.toString());
733                        QueryExecution qexec = QueryExecutionFactory.sparqlService(
734                                        endpointURI, query);
735
736                        ResultSet results = qexec.execSelect();
737                        if (results.hasNext()) {
738                                QuerySolution sol = results.next();
739                                Literal lit = sol.getLiteral("numOfLinks");
740                                if (lit != null) {
741                                        int numOfLinks = lit.getInt();
742                                        classLink.setNumOfLinks(numOfLinks);
743                                }
744                        }
745                        qexec.close();
746                }
747                return classLinks;
748        }
749
[31]750        public SClass[] countInstances(String[] graphURIs, SClass[] classes) throws Exception{
751                if( classes == null || classes.length == 0 ){
752                        return new SClass[0];
753                }
754                HashMap<String, SClass> classMap = new HashMap<String, SClass>();
755                for(SClass sc: classes){
756                        classMap.put(sc.getClassURI(), sc);
757                }
758                StringBuffer queryStr = new StringBuffer();
759                queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
760                queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
761                queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
762                queryStr.append("SELECT DISTINCT ?cls  (COUNT(?is) AS ?numOfInstances)\n");
763                if (graphURIs != null) {
764                        for (String graphURI : graphURIs) {
765                                queryStr.append("FROM <");
766                                queryStr.append(graphURI);
767                                queryStr.append(">\n");
768                        }
769                }
770                queryStr.append("WHERE{\n");
771                queryStr.append("  ?is rdf:type ?cls.\n");
772                queryStr.append("  FILTER(?cls IN (");
773                boolean f = false;
774                Set<String> clsSet = classMap.keySet();
775                for (String clsURI : clsSet) {
776                        if (f) {
777                                queryStr.append(", ");
778                        }
779                        f = true;
780                        queryStr.append("<");
781                        queryStr.append(clsURI);
782                        queryStr.append(">");
783                }
784                queryStr.append("))\n");
785                queryStr.append("} GROUP BY ?cls");
786
787                System.out.println(queryStr.toString());
788
789                Query query = QueryFactory.create(queryStr.toString());
790                QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
791                                query);
792
793                ResultSet results = qexec.execSelect();
794                for (; results.hasNext();) {
795                        QuerySolution sol = results.next();
796                        String uri = sol.getResource("cls").getURI();
797                        SClass sc = classMap.get(uri);
798                        Literal lit = sol.getLiteral("numOfInstances");
799                        if (lit != null) {
800                                int numOfInstances = lit.getInt();
801                                sc.setNumOfInstances(numOfInstances);
802                        }
803                }
804                qexec.close();
805       
806                return classes;
807        }
808
[2]809}
Note: リポジトリブラウザについてのヘルプは TracBrowser を参照してください。