Context Navigation

OWLQueryBuilderImpl.java @ 55

リビジョン 55, 35.2 KB (コミッタ: nori, 11 年前)
クラス検索機能について、複数のキーワードが指定できるよう、引数をStringからString[]に変更
属性 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 {
[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{
	257
	258	//TODO
	259	return null;
	260	}
	261
	262
	263
[2]	264	/**
[22]	265	* 縲繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧貞叙蠕励☆繧�
[2]	266	* <p>
[22]	267	* 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧偵☆縺ｹ縺ｦ霑斐☆ <br>
	268	* 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
[2]	269	* </p>
	270	*
[22]	271	* @param graphURIs
	272	* 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� (null繧�聞縺�縺ｮ驟榊�繧ょ庄)
	273	* @param keyword
	274	* ��ull繧�ｩｺ譁�ｭ励�荳榊庄��
[2]	275	* @return 繧ｯ繝ｩ繧ｹURI縺ｮ驟榊�
	276	* @throws Exception
	277	* @since 28.01.2014
	278	*/
	279	public Instance[] getInstances(String[] graphURIs, String keyword)
	280	throws Exception {
	281	StringBuffer queryStr = new StringBuffer();
	282	queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
	283	queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
	284	queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
	285	queryStr.append("SELECT DISTINCT ?ins ?c \n");
	286	if (graphURIs != null) {
	287	for (String graphURI : graphURIs) {
	288	queryStr.append("FROM <");
	289	queryStr.append(graphURI);
	290	queryStr.append(">\n");
	291	}
	292	}
	293	queryStr.append("WHERE{\n");
[22]	294	// queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n");
[2]	295
	296	queryStr.append(" ?ins rdf:type ?c.\n");
	297	queryStr.append(" ?ins rdfs:label ");
	298	queryStr.append(keyword);
	299	queryStr.append(".\n");
	300	queryStr.append(" FILTER (?c != rdf:Property)");
	301	queryStr.append("}");
[22]	302
	303	// System.out.println(queryStr.toString());
	304
[2]	305	Query query = QueryFactory.create(queryStr.toString());
	306	QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
	307	query);
	308
	309	ResultSet results = qexec.execSelect();
	310	HashMap<String, HashSet<String>> instanceMap = new HashMap<String, HashSet<String>>();
	311	for (; results.hasNext();) {
	312	QuerySolution sol = results.next();
	313	Resource cls = sol.getResource("c");
	314	Resource ins = sol.getResource("ins");
	315	String clsURI = cls.getURI();
	316	String insURI = ins.getURI();
[22]	317	if (instanceMap.containsKey(insURI)) {
[2]	318	HashSet<String> classes = instanceMap.get(insURI);
	319	classes.add(clsURI);
[22]	320	} else {
[2]	321	HashSet<String> classes = new HashSet<String>();
	322	instanceMap.put(insURI, classes);
	323	classes.add(clsURI);
	324	}
	325	}
	326	qexec.close();
	327	Set<String> keySet = instanceMap.keySet();
	328	ArrayList<Instance> instanceList = new ArrayList<Instance>();
[22]	329	for (String key : keySet) {
	330	Instance ins = new Instance(key, instanceMap.get(key).toArray(
	331	new String[0]));
[2]	332	instanceList.add(ins);
	333	}
	334	return instanceList.toArray(new Instance[0]);
	335	}
	336
	337	/**
[22]	338	* 縲謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励∵�遉ｺ逧�↓險倩ｿｰ縺輔ｌ縺ｦ縺�ｋOWL縺ｮproperty蛻ｶ邏�ｒ隱ｿ縺ｹ縲√◎縺ｮproperty蛻ｶ邏�〒
[2]	339	* 髢｢騾｣縺･縺代ｉ繧後※縺�ｋ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
	340	* <p>
[22]	341	* 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
[2]	342	* <br>
	343	* </p>
	344	*
[22]	345	* @param graphURIs
	346	* 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
	347	* @param originClass
	348	* 襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲��ull荳榊庄��
	349	* @param limit
	350	* 隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
[2]	351	* @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
	352	* @throws Exception
	353	* @since 28.01.2014
	354	*/
	355	public ClassLink[] getNextClass(String[] graphURIs, String originClass,
[20]	356	int limit, boolean countLinks) throws Exception {
[42]	357	ClassLink[] cLinks = getNextClassSub(graphURIs, originClass, limit, false);
	358	if( countLinks ){
	359	cLinks = countLinks(graphURIs, originClass, cLinks);
	360	}
	361	return cLinks;
	362	}
	363
	364	private ClassLink[] getNextClassSub(String[] graphURIs, String originClass,
	365	int limit, boolean countLinks) throws Exception {
	366	StringBuffer queryStr = new StringBuffer();
[2]	367	queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
	368	queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
	369	queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
[20]	370
	371	// SELECT
[22]	372	if (countLinks) {
[49]	373	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]	374	} else {
[20]	375	queryStr.append("SELECT DISTINCT ?p ?pDirection ?c \n");
	376	}
[22]	377
[2]	378	if (graphURIs != null) {
	379	for (String graphURI : graphURIs) {
	380	queryStr.append("FROM <");
	381	queryStr.append(graphURI);
	382	queryStr.append(">\n");
	383	}
	384	}
	385	queryStr.append("WHERE{\n");
[28]	386	// queryStr.append(" { ?c rdf:type rdfs:Class. }\n UNION\n { ?c rdf:type owl:Class. }\n");
[2]	387	queryStr.append(" { ?p rdfs:domain <");
	388	queryStr.append(originClass);
[19]	389	queryStr.append(">.\n ?p rdfs:range ?c.\n");
[27]	390
[22]	391	if (countLinks) {
	392	queryStr.append(" ?o ?p ?s.");
[28]	393	} else {
[27]	394	queryStr.append("filter(exists{\n");
	395	queryStr.append(" ?o rdf:type ?c.\n");
	396	queryStr.append(" ?s rdf:type <");
	397	queryStr.append(originClass);
	398	queryStr.append(">.\n");
	399	queryStr.append(" ?s ?p ?o.})\n");
[20]	400	}
[22]	401
[19]	402	queryStr.append("}\n UNION\n");
[2]	403	queryStr.append(" { ?p rdfs:range <");
	404	queryStr.append(originClass);
[5]	405	queryStr.append(">.\n");
	406	queryStr.append(" ?p rdfs:domain ?c.\n");
[20]	407
[22]	408	if (countLinks) {
	409	queryStr.append(" ?s ?p ?o.");
[28]	410	} else {
[27]	411	queryStr.append("filter(exists{\n");
	412	queryStr.append(" ?s rdf:type ?c.\n");
	413	queryStr.append(" ?o rdf:type <");
	414	queryStr.append(originClass);
	415	queryStr.append(">.\n");
	416	queryStr.append(" ?s ?p ?o.})\n");
[20]	417	}
[22]	418
[19]	419	queryStr.append("}\n");
[5]	420
	421	queryStr.append(" ?p ?pDirection ?c.\n");
	422
[54]	423	// queryStr.append(" ?s rdf:type ?c.\n");
[20]	424
[22]	425	if (countLinks) {
[20]	426	queryStr.append("}\nGROUP BY ?p ?pDirection ?c\n");
[22]	427	} else {
[20]	428	queryStr.append("}\n");
	429	}
[2]	430	if (limit > 0) {
	431	queryStr.append("limit ");
	432	queryStr.append(limit);
	433	queryStr.append("\n");
	434	}
[22]	435
[46]	436	System.out.println("getNextClasses SPARQL Query: ");
[22]	437	System.out.println(queryStr.toString());
	438
[2]	439	Query query = QueryFactory.create(queryStr.toString());
[46]	440	QueryExecution qexec = null;
	441	try{
	442	qexec = QueryExecutionFactory.sparqlService(endpointURI,
[2]	443	query);
[46]	444	}catch(Exception ex){
	445	ex.printStackTrace();
	446	throw ex;
	447	}
	448
	449	ResultSet results = null;
	450	try{
	451	long start = System.currentTimeMillis();
	452	results = qexec.execSelect();
	453	long end = System.currentTimeMillis();
	454	System.out.println("EXEC TIME: " + (end-start));
	455	}catch(Exception ex){
	456	ex.printStackTrace();
	457	throw ex;
	458	}
	459
[2]	460	ArrayList<ClassLink> solCLs = new ArrayList<ClassLink>();
	461	for (; results.hasNext();) {
	462	QuerySolution sol = results.next();
	463	Resource pro = sol.getResource("p");
[22]	464	if (pro != null) {
	465	Resource cls = sol.getResource("c");
	466	Resource dir = sol.getResource("pDirection");
	467	String proURI = pro.getURI();
	468	String clsURI = cls.getURI();
	469	String dirURI = dir.getURI();
[2]	470
[22]	471	// System.out.println(pro.getURI() + " " + cls.getURI() + " " +
	472	// dir.getURI());
	473
	474	Direction direction = null;
	475	if (dirURI
	476	.equals("http://www.w3.org/2000/01/rdf-schema#domain")
	477	\|\| dirURI.equals("rdfs:domain")) {
	478	direction = Direction.reverse;
[2]	479	}
[22]	480	if (dirURI.equals("http://www.w3.org/2000/01/rdf-schema#range")
	481	\|\| dirURI.equals("rdfs:range")) {
	482	if (direction != null) {
	483	direction = Direction.both;
	484	} else {
	485	direction = Direction.forward;
	486	}
	487	}
	488	// System.out.println(direction);
[23]	489	int numOfLinks = 0;
[26]	490	if (countLinks) {
	491	numOfLinks = sol.getLiteral("numOfLinks").getInt();
[23]	492	}
[22]	493	ClassLink cl = new ClassLink(proURI, clsURI, direction,
[49]	494	numOfLinks, 0, 0, 0, 0 );
[22]	495	solCLs.add(cl);
[2]	496	}
	497	}
	498	qexec.close();
	499	return solCLs.toArray(new ClassLink[0]);
	500	}
[22]	501
[2]	502	/**
[22]	503	* 縲謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励√◎縺ｮ繧ｯ繝ｩ繧ｹ縺ｫ螻槭＠縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励＠縲�
	504	* 蜿門ｾ励＠縺溘う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
[2]	505	* <p>
[22]	506	* 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
	507	* 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
[2]	508	* </p>
	509	*
[22]	510	* @param graphURIs
	511	* 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
	512	* @param originClass
	513	* 襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲��ull荳榊庄��
	514	* @param limit
	515	* 隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
[2]	516	* @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
	517	* @throws Exception
	518	* @since 28.01.2014
	519	*/
[22]	520	public ClassLink[] getNextClassViaInstanceLink(String[] graphURIs,
	521	String originClass, int limit) throws Exception {
[2]	522	StringBuffer queryStr = new StringBuffer();
	523	queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
	524	queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
	525	queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
[49]	526	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]	527	if (graphURIs != null) {
	528	for (String graphURI : graphURIs) {
	529	queryStr.append("FROM <");
	530	queryStr.append(graphURI);
	531	queryStr.append(">\n");
	532	}
	533	}
	534	queryStr.append("WHERE{\n");
	535	queryStr.append(" ?ins rdf:type ?c.\n");
	536	queryStr.append(" ?insOrg rdf:type <");
	537	queryStr.append(originClass);
	538	queryStr.append(">.\n");
	539	queryStr.append(" { ?ins ?pr ?insOrg. }\n UNION { ?insOrg ?pf ?ins. }\n");
	540	queryStr.append("}\n");
[49]	541	queryStr.append("GROUP BY ?pf ?pr ?c\n");
[2]	542	if (limit > 0) {
	543	queryStr.append("limit ");
	544	queryStr.append(limit);
	545	queryStr.append("\n");
	546	}
[22]	547
[46]	548	System.out.println(queryStr.toString());
[22]	549
[2]	550	Query query = QueryFactory.create(queryStr.toString());
	551	QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
	552	query);
	553
[49]	554	ResultSet results = null;
	555	try{
	556	long start = System.currentTimeMillis();
	557	results = qexec.execSelect();
	558	long end = System.currentTimeMillis();
	559	System.out.println("EXEC TIME: " + (end-start));
	560	}catch(Exception ex){
	561	ex.printStackTrace();
	562	throw ex;
	563	}
	564
[2]	565	ArrayList<ClassLink> solCLs = new ArrayList<ClassLink>();
	566	for (; results.hasNext();) {
	567	QuerySolution sol = results.next();
	568	Resource proForward = sol.getResource("pf");
	569	Resource proReverse = sol.getResource("pr");
	570	Resource cls = sol.getResource("c");
	571	Direction direction = null;
	572	String propURI = null;
[49]	573	int numOfLinks = 0;
	574	int numOfLinkedInstances = 0;
	575	int numOfOriginInstances = 0;
[22]	576	if (proForward != null) {
	577	if (proReverse != null) {
[49]	578	numOfLinks = sol.getLiteral("numOfForwardLinks").getInt();
	579	numOfLinks += sol.getLiteral("numOfReverseLinks").getInt();
	580	numOfLinkedInstances = sol.getLiteral("numOfLinkedInstances").getInt();
	581	numOfOriginInstances = sol.getLiteral("numOfOriginInstances").getInt();
[2]	582	direction = Direction.both;
[22]	583	} else {
[49]	584	numOfLinkedInstances = sol.getLiteral("numOfLinkedInstances").getInt();
	585	numOfOriginInstances = sol.getLiteral("numOfOriginInstances").getInt();
	586	numOfLinks = sol.getLiteral("numOfForwardLinks").getInt();
[2]	587	direction = Direction.forward;
	588	}
	589	propURI = proForward.getURI();
[22]	590	} else {
[2]	591	direction = Direction.reverse;
	592	propURI = proReverse.getURI();
[49]	593	numOfLinkedInstances = sol.getLiteral("numOfOriginInstances").getInt();
	594	numOfOriginInstances = sol.getLiteral("numOfLinkedInstances").getInt();
	595	numOfLinks = sol.getLiteral("numOfReverseLinks").getInt();
[2]	596	}
	597	String clsURI = cls.getURI();
[22]	598	// System.out.println(propURI + " " + clsURI + " " + direction);
	599
[49]	600	ClassLink cl = new ClassLink(propURI, clsURI, direction, numOfLinks, numOfOriginInstances, numOfLinkedInstances, 0, 0);
[2]	601	solCLs.add(cl);
	602	}
	603	qexec.close();
	604	return solCLs.toArray(new ClassLink[0]);
	605	}
	606
[36]	607	public Path[] getPaths(String startClass, String endClass, int mode,
	608	boolean countLinks) throws Exception {
[2]	609	OWLClassGraph graph = new OWLClassGraph(startClass, endClass);
[32]	610	return graph.getPaths(this, mode, countLinks);
[2]	611	}
	612
	613	public String createSPARQL(Path path) throws Exception {
	614	return null;
	615	}
	616
[22]	617	/*
	618	* private String executeSelect(String sparqlQuery) throws Exception {
	619	* HttpClient client = HttpClientBuilder.create().build(); HttpPost httppost
	620	* = new HttpPost(endpointURI); httppost.setHeader("Content-Type",
	621	* "application/x-www-form-urlencoded"); httppost.setHeader("Accept",
	622	* "application/sparql-results+xml"); List<NameValuePair> nvpList = new
	623	* ArrayList<NameValuePair>(); nvpList.add(new BasicNameValuePair("query",
	624	* sparqlQuery)); // nvpList.add(new BasicNameValuePair("format", //
	625	* outputFormat.getMime())); httppost.setEntity(new
	626	* UrlEncodedFormEntity(nvpList, Charset .forName("UTF-8"))); HttpResponse
	627	* response = client.execute(httppost); //
	628	* System.out.println("[StatusLine] " + response.getStatusLine());
	629	* HttpEntity entity = response.getEntity(); String entityString =
	630	* EntityUtils.toString(entity, "UTF-8"); return entityString; }
	631	*/
[2]	632
	633	/**
[22]	634	* 縲謖�ｮ壹＆繧後◆繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励√◎縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｫ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励☆繧九�
	635	* 縲蜿門ｾ励＆繧後◆蜷�う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧らｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧�
[2]	636	* <p>
[22]	637	* 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺�<br>
	638	* 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ <br>
[2]	639	* </p>
	640	*
[22]	641	* @param graphURIs
	642	* 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲(null繧�聞縺�縺ｮ驟榊�繧ょ庄)
	643	* @param originInstance
	644	* 襍ｷ轤ｹ縺ｨ縺ｪ繧九う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI縲��ull荳榊庄��
	645	* @param limit
	646	* 隗｣縺ｨ縺励※霑斐＆繧後ｋInstanceLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧�
[2]	647	* @return InstanceLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲�
	648	* @throws Exception
	649	* @since 28.01.2014
	650	*/
[22]	651	public InstanceLink[] getNextInstancesViaInstanceLink(String[] graphURIs,
	652	String originInstance, int limit) throws Exception {
[2]	653	StringBuffer queryStr = new StringBuffer();
	654	queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
	655	queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
	656	queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
	657	queryStr.append("SELECT DISTINCT ?pf ?pr ?ins ?c \n");
	658	if (graphURIs != null) {
	659	for (String graphURI : graphURIs) {
	660	queryStr.append("FROM <");
	661	queryStr.append(graphURI);
	662	queryStr.append(">\n");
	663	}
	664	}
	665	queryStr.append("WHERE{\n");
[22]	666	// queryStr.append(" { ?c rdf:type rdfs:Class. }\n UNION\n { ?c rdf:type owl:Class. }\n");
[2]	667	queryStr.append(" ?ins rdf:type ?c.\n");
	668	queryStr.append(" { ?ins ?pr <");
	669	queryStr.append(originInstance);
	670	queryStr.append(">. }\n UNION { <");
	671	queryStr.append(originInstance);
	672	queryStr.append("> ?pf ?ins. }\n");
	673
	674	queryStr.append(" FILTER (?c != rdf:Property)");
	675
	676	queryStr.append("}\n");
	677	if (limit > 0) {
	678	queryStr.append("limit ");
	679	queryStr.append(limit);
	680	queryStr.append("\n");
	681	}
[22]	682
	683	// System.out.println(queryStr.toString());
	684
[2]	685	Query query = QueryFactory.create(queryStr.toString());
	686	QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
	687	query);
	688
	689	ResultSet results = qexec.execSelect();
	690	HashMap<String, InstanceLink> insLinkMap = new HashMap<String, InstanceLink>();
	691	for (; results.hasNext();) {
	692	QuerySolution sol = results.next();
	693	Resource proForward = sol.getResource("pf");
	694	Resource proReverse = sol.getResource("pr");
	695	Resource ins = sol.getResource("ins");
	696	Resource cls = sol.getResource("c");
	697	Direction direction = null;
	698	String propURI = null;
[22]	699	if (proForward != null) {
	700	if (proReverse != null) {
[2]	701	direction = Direction.both;
[22]	702	} else {
[2]	703	direction = Direction.forward;
	704	}
	705	propURI = proForward.getURI();
[22]	706	} else {
[2]	707	direction = Direction.reverse;
	708	propURI = proReverse.getURI();
	709	}
	710	String clsURI = cls.getURI();
	711	String insURI = ins.getURI();
	712	String key = propURI + "\t" + insURI + "\t" + direction;
[22]	713	if (insLinkMap.containsKey(key)) {
[2]	714	InstanceLink insLink = insLinkMap.get(key);
	715	insLink.addLinkedClassURI(clsURI);
[22]	716	} else {
	717	InstanceLink insLink = new InstanceLink(propURI, insURI,
	718	new String[] { clsURI }, direction);
[2]	719	insLinkMap.put(key, insLink);
	720	}
	721	}
	722	qexec.close();
	723	Collection<InstanceLink> values = insLinkMap.values();
	724	return values.toArray(new InstanceLink[0]);
	725	}
	726
[22]	727	public LabelMap[] getLabels(String[] graphURIs, String[] resourceURIs,
	728	String language) throws Exception {
	729	if (resourceURIs == null \|\| resourceURIs.length == 0) {
[19]	730	return new LabelMap[0];
	731	}
	732	StringBuffer queryStr = new StringBuffer();
	733	queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
	734	queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
	735	queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
	736	queryStr.append("SELECT DISTINCT ?res ?label \n");
	737	if (graphURIs != null) {
	738	for (String graphURI : graphURIs) {
	739	queryStr.append("FROM <");
	740	queryStr.append(graphURI);
	741	queryStr.append(">\n");
	742	}
	743	}
	744	queryStr.append("WHERE{\n");
	745	queryStr.append(" ?res rdfs:label ?label.\n");
	746	queryStr.append(" FILTER(?res IN (");
	747	boolean f = false;
[22]	748	for (String resourceURI : resourceURIs) {
	749	if (f) {
[19]	750	queryStr.append(", ");
	751	}
	752	f = true;
	753	queryStr.append("<");
	754	queryStr.append(resourceURI);
	755	queryStr.append(">");
	756	}
	757	queryStr.append("))\n");
	758	queryStr.append("}");
[22]	759
	760	System.out.println(queryStr.toString());
	761
[19]	762	Query query = QueryFactory.create(queryStr.toString());
	763	QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
	764	query);
	765
	766	ResultSet results = qexec.execSelect();
	767	HashMap<String, LabelMap> lMap = new HashMap<String, LabelMap>();
	768	for (; results.hasNext();) {
	769	QuerySolution sol = results.next();
	770	String uri = sol.getResource("res").getURI();
	771	Literal literal = sol.getLiteral("label");
[22]	772	if (literal != null) {
[19]	773	String label = literal.getString();
	774	String lang = literal.getLanguage();
[22]	775	if (language != null && language.equals(lang)) {
[19]	776	Label lbl = new Label(label, lang);
[22]	777	if (lMap.containsKey(uri)) {
[19]	778	LabelMap lm = lMap.get(uri);
	779	lm.addLabel(lbl);
[22]	780	} else {
	781	LabelMap lm = new LabelMap(uri, new Label[] { lbl });
[19]	782	lMap.put(uri, lm);
	783	}
	784	}
	785	}
	786	}
	787	return lMap.values().toArray(new LabelMap[0]);
	788	}
[22]	789
[26]	790	public ClassLink[] countLinks(String[] graphURIs, String startClassURI,
	791	ClassLink[] classLinks) throws Exception {
	792	if (classLinks == null \|\| classLinks.length == 0) {
	793	return new ClassLink[0];
	794	}
	795	for (ClassLink classLink : classLinks) {
	796	StringBuffer queryStr = new StringBuffer();
	797	queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
	798	queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
	799	queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
	800
[46]	801	queryStr.append("SELECT (COUNT(?os) AS ?numOfLinks) (COUNT(DISTINCT(?is)) AS ?numOfOriginInstances) (COUNT(DISTINCT(?os)) AS ?numOfLinkedInstances) \n");
[26]	802	if (graphURIs != null) {
	803	for (String graphURI : graphURIs) {
	804	queryStr.append("FROM <");
	805	queryStr.append(graphURI);
	806	queryStr.append(">\n");
	807	}
	808	}
	809
	810	queryStr.append("WHERE{\n");
	811	if (classLink.getDirection() == Direction.forward) {
	812	queryStr.append("?is rdf:type <");
	813	queryStr.append(startClassURI);
	814	queryStr.append(">.\n");
	815	queryStr.append("?os rdf:type <");
	816	queryStr.append(classLink.getLinkedClassURI());
	817	queryStr.append(">.\n");
[42]	818	queryStr.append("?is <");
	819	queryStr.append(classLink.getPropertyURI());
	820	queryStr.append("> ?os.\n");
[26]	821	queryStr.append("}");
	822	} else {
	823	if (classLink.getDirection() == Direction.forward) {
	824	queryStr.append("?os rdf:type <");
	825	queryStr.append(startClassURI);
	826	queryStr.append(">.\n");
	827	queryStr.append("?is rdf:type <");
	828	queryStr.append(classLink.getLinkedClassURI());
	829	queryStr.append(">.\n");
[42]	830	queryStr.append("?is <");
	831	queryStr.append(classLink.getPropertyURI());
	832	queryStr.append("> ?os.\n");
[26]	833	queryStr.append("}");
	834	} else {
	835	queryStr.append("?os rdf:type <");
	836	queryStr.append(startClassURI);
	837	queryStr.append(">.\n");
	838	queryStr.append("?is rdf:type <");
	839	queryStr.append(classLink.getLinkedClassURI());
	840	queryStr.append(">.\n");
[42]	841	queryStr.append("{?is <");
	842	queryStr.append(classLink.getPropertyURI());
	843	queryStr.append("> ?os.}\n");
[26]	844	queryStr.append("UNION\n");
[42]	845	queryStr.append("{?os <");
	846	queryStr.append(classLink.getPropertyURI());
	847	queryStr.append("> ?is.}\n");
[26]	848	queryStr.append("}");
	849	}
	850	}
	851	System.out.println(queryStr.toString());
	852
	853	Query query = QueryFactory.create(queryStr.toString());
	854	QueryExecution qexec = QueryExecutionFactory.sparqlService(
	855	endpointURI, query);
	856
	857	ResultSet results = qexec.execSelect();
	858	if (results.hasNext()) {
	859	QuerySolution sol = results.next();
	860	Literal lit = sol.getLiteral("numOfLinks");
	861	if (lit != null) {
	862	int numOfLinks = lit.getInt();
	863	classLink.setNumOfLinks(numOfLinks);
	864	}
[46]	865	lit = sol.getLiteral("numOfLinkedInstances");
	866	if (lit != null) {
	867	int numOfLinkedInstances = lit.getInt();
	868	classLink.setNumOfLinkedInstances(numOfLinkedInstances);
	869	}
	870	lit = sol.getLiteral("numOfOriginInstances");
	871	if (lit != null) {
	872	int numOfOriginInstances = lit.getInt();
	873	classLink.setNumOfOriginInstances(numOfOriginInstances);
	874	}
[49]	875	lit = sol.getLiteral("numOfOriginClassInstances");
	876	if (lit != null) {
	877	int numOfOriginClassInstances = lit.getInt();
	878	classLink.setNumOfOriginClassInstances(numOfOriginClassInstances);
	879	}
	880	lit = sol.getLiteral("numOfLinkedClassInstances");
	881	if (lit != null) {
	882	int numOfLinkedClassInstances = lit.getInt();
	883	classLink.setNumOfLinkedClassInstances(numOfLinkedClassInstances);
	884	}
[26]	885	}
	886	qexec.close();
[49]	887
	888	// count instances
	889	queryStr = new StringBuffer();
	890	queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
	891	queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
	892	queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
	893
	894	queryStr.append("SELECT (COUNT(?ics) AS ?numOfOriginClassInstances) \n");
	895	if (graphURIs != null) {
	896	for (String graphURI : graphURIs) {
	897	queryStr.append("FROM <");
	898	queryStr.append(graphURI);
	899	queryStr.append(">\n");
	900	}
	901	}
	902
	903	queryStr.append("WHERE{\n");
	904	if (classLink.getDirection() == Direction.forward) {
	905	queryStr.append("?ics rdf:type <");
	906	queryStr.append(startClassURI);
	907	queryStr.append(">.\n");
	908	queryStr.append("}");
	909	} else {
	910	if (classLink.getDirection() == Direction.forward) {
	911	queryStr.append("?ics rdf:type <");
	912	queryStr.append(classLink.getLinkedClassURI());
	913	queryStr.append(">.\n");
	914	queryStr.append("}");
	915	} else {
	916	queryStr.append("?ics rdf:type <");
	917	queryStr.append(classLink.getLinkedClassURI());
	918	queryStr.append(">.\n");
	919	queryStr.append("}");
	920	}
	921	}
	922
	923	System.out.println(queryStr.toString());
	924
	925	query = QueryFactory.create(queryStr.toString());
	926	qexec = QueryExecutionFactory.sparqlService(
	927	endpointURI, query);
	928
	929	results = qexec.execSelect();
	930	if (results.hasNext()) {
	931	QuerySolution sol = results.next();
	932	Literal lit = null;
	933	lit = sol.getLiteral("numOfOriginClassInstances");
	934	if (lit != null) {
	935	int numOfOriginClassInstances = lit.getInt();
	936	classLink.setNumOfOriginClassInstances(numOfOriginClassInstances);
	937	}
	938	}
	939	qexec.close();
	940
	941	// count instances
	942	queryStr = new StringBuffer();
	943	queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
	944	queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
	945	queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
	946
	947	queryStr.append("SELECT (COUNT(?ocs) AS ?numOfLinkedClassInstances) \n");
	948	if (graphURIs != null) {
	949	for (String graphURI : graphURIs) {
	950	queryStr.append("FROM <");
	951	queryStr.append(graphURI);
	952	queryStr.append(">\n");
	953	}
	954	}
	955
	956	queryStr.append("WHERE{\n");
	957	if (classLink.getDirection() == Direction.forward) {
	958	queryStr.append("?ocs rdf:type <");
	959	queryStr.append(classLink.getLinkedClassURI());
	960	queryStr.append(">.\n");
	961	queryStr.append("}");
	962	} else {
	963	if (classLink.getDirection() == Direction.forward) {
	964	queryStr.append("?ocs rdf:type <");
	965	queryStr.append(startClassURI);
	966	queryStr.append(">.\n");
	967	queryStr.append("}");
	968	} else {
	969	queryStr.append("?ocs rdf:type <");
	970	queryStr.append(startClassURI);
	971	queryStr.append(">.\n");
	972	queryStr.append("}");
	973	}
	974	}
	975
	976	System.out.println(queryStr.toString());
	977
	978	query = QueryFactory.create(queryStr.toString());
	979	qexec = QueryExecutionFactory.sparqlService(
	980	endpointURI, query);
	981
	982	results = qexec.execSelect();
	983	if (results.hasNext()) {
	984	QuerySolution sol = results.next();
	985	Literal lit = null;
	986	lit = sol.getLiteral("numOfLinkedClassInstances");
	987	if (lit != null) {
	988	int numOfLinkedClassInstances = lit.getInt();
	989	classLink.setNumOfLinkedClassInstances(numOfLinkedClassInstances);
	990	}
	991	}
	992	qexec.close();
	993
[26]	994	}
	995	return classLinks;
	996	}
	997
[49]	998
[36]	999	public SClass[] countInstances(String[] graphURIs, SClass[] classes)
	1000	throws Exception {
	1001	if (classes == null \|\| classes.length == 0) {
[31]	1002	return new SClass[0];
	1003	}
	1004	HashMap<String, SClass> classMap = new HashMap<String, SClass>();
[36]	1005	for (SClass sc : classes) {
[31]	1006	classMap.put(sc.getClassURI(), sc);
	1007	}
	1008	StringBuffer queryStr = new StringBuffer();
	1009	queryStr.append("PREFIX owl: <http://www.w3.org/2002/07/owl#>\n");
	1010	queryStr.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
	1011	queryStr.append("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n");
	1012	queryStr.append("SELECT DISTINCT ?cls (COUNT(?is) AS ?numOfInstances)\n");
	1013	if (graphURIs != null) {
	1014	for (String graphURI : graphURIs) {
	1015	queryStr.append("FROM <");
	1016	queryStr.append(graphURI);
	1017	queryStr.append(">\n");
	1018	}
	1019	}
	1020	queryStr.append("WHERE{\n");
	1021	queryStr.append(" ?is rdf:type ?cls.\n");
	1022	queryStr.append(" FILTER(?cls IN (");
	1023	boolean f = false;
	1024	Set<String> clsSet = classMap.keySet();
	1025	for (String clsURI : clsSet) {
	1026	if (f) {
	1027	queryStr.append(", ");
	1028	}
	1029	f = true;
	1030	queryStr.append("<");
	1031	queryStr.append(clsURI);
	1032	queryStr.append(">");
	1033	}
	1034	queryStr.append("))\n");
	1035	queryStr.append("} GROUP BY ?cls");
	1036
	1037	System.out.println(queryStr.toString());
	1038
	1039	Query query = QueryFactory.create(queryStr.toString());
	1040	QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI,
	1041	query);
	1042
	1043	ResultSet results = qexec.execSelect();
	1044	for (; results.hasNext();) {
	1045	QuerySolution sol = results.next();
	1046	String uri = sol.getResource("cls").getURI();
	1047	SClass sc = classMap.get(uri);
	1048	Literal lit = sol.getLiteral("numOfInstances");
	1049	if (lit != null) {
	1050	int numOfInstances = lit.getInt();
	1051	sc.setNumOfInstances(numOfInstances);
	1052	}
	1053	}
	1054	qexec.close();
[36]	1055
[31]	1056	return classes;
	1057	}
	1058
[2]	1059	}

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

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

元の形式