Context Navigation

OWLQueryBuilderImpl.java @ 27

リビジョン 27, 25.3 KB (コミッタ: nori, 11 年前)
getNextClass のexists句を変えてSPARQLの処理速度が向上したはず
属性 svn:mime-type の設定値 `text/plain`

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

Note: リポジトリブラウザについてのヘルプは TracBrowser を参照してください。

異なるフォーマットでダウンロード:

元の形式