+ * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧ｯ繝ｩ繧ｹ��dfs:Class�峨ｒ縺吶∋縺ｦ霑斐☆ + * + *
+ * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧偵☆縺ｹ縺ｦ霑斐☆ + * + * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + * + *
+ * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + * + * + *
+ * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + * + * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + * + *
+ * 蜷代″縺ｮ隗｣驥医�縺薙�縲Direction 縺御ｽｿ逕ｨ縺輔ｌ繧狗憾豕√↓蠢懊§縺ｦ螳壹∪繧� + * + * @author Norio KOBAYASHI + * @since 28.01.2014 + * @version 29.01.2014 + */ +public enum Direction { + /** + * 鬆�婿蜷� + */ + forward, + + /** + * 騾�婿蜷� + */ + reverse, + + /** + * 荳｡譁ｹ蜷� + */ + both; +} Index: /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/StructureCrawler.java =================================================================== --- /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/StructureCrawler.java (revision 123) +++ /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/StructureCrawler.java (revision 123) @@ -0,0 +1,116 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.io.File; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +import jp.riken.accc.db.rdf.crawler.dataStructure.SchemaCategory; +import jp.riken.accc.db.rdf.crawler.dataStructure.sparql.JenaModelGenerator; +import jp.riken.accc.db.rdf.crawler.dataStructure.sparql.RDFsCrawlerImpl; + +public class StructureCrawler { + + private File dataDir = null; + + // this is just for a test + public static void main(String[] args) throws Exception{ + StructureCrawler sc = new StructureCrawler(new File("c:\\cdata")); +// sc.crawl("http://dbe-rdf.biosciencedbc.jp/sparql", "biosciencedbc.ttl"); + +// System.out.println("done"); + + + Map acTable = sc.getAcquiredStructureFiles(); + Set keySet = acTable.keySet(); + for(String key: keySet){ + String val = acTable.get(key); + System.out.println("File: " + key + " --- " + val); + } + } + + + + public Map getAcquiredStructureFiles(){ + Map table = new HashMap(); + if( dataDir.isDirectory() ){ + // read files + File[] files = dataDir.listFiles(); + for(File file: files){ + String uri = null; + try{ + JenaModelGenerator jmGene = new JenaModelGenerator(file.getAbsolutePath()); + uri = jmGene.getEndpointURI(); +System.out.println("URI: "+ uri); + }catch(Exception ex){ + // + } + if( uri != null ){ + table.put(uri, file.getAbsolutePath()); + } + } + }else{ + if( dataDir.isFile() ){ + String uri = null; + try{ + JenaModelGenerator jmGene = new JenaModelGenerator(dataDir.getAbsolutePath()); + uri = jmGene.getEndpointURI(); + + }catch(Exception ex){ + // + } + if( uri != null ){ + table.put(uri, dataDir.getAbsolutePath()); + } + } + } + return table; + } + + + + public StructureCrawler(File dataDir) throws Exception { + this.dataDir = dataDir; + } + + public void crawl(String endPURI, String outFileName) throws Exception { + RDFsCrawlerImpl impl = new RDFsCrawlerImpl(endPURI); + // Resource[] res = impl.getRDFProperties(); + // Resource[] res = impl.getInferedRDFsClassesFromInstances(); + // Resource[] res = impl.getDomainRangeDeclaredRDFProperties(); + // Resource[] res = impl.getDeclaredRDFsClasses(); + // for(Resource r: res){ + // System.out.println(r.getURI().toString()); + // } + // Model model = impl.getProperiesFromDomainRangeDecls(); + // Model model = impl.getPropertiesFromInstanceDecls(); + // RDFWriter writer = model.getWriter("N3"); + // writer.setProperty("showXMLDeclaration","true"); + // writer.write(model,System.out,""); + // model.close(); + + SchemaCategory sc = impl.determineSchemaCategory(); + + // RDF/XML, RDF/XML-ABBREV, N-TRIPLE, N3 + File outFile = null; + if (outFileName == null) { + String tFileName = null; + if (endPURI.lastIndexOf("/", endPURI.length() - 2) > 0) { + tFileName = endPURI.substring( + endPURI.lastIndexOf("/", endPURI.length() - 2) + 1, + endPURI.length()); + } else { + tFileName = endPURI; + } + outFile = new File(dataDir, tFileName); + if (outFile.exists()) { + outFile = File.createTempFile(tFileName, "", dataDir); + } + } else { + outFile = new File(dataDir, outFileName); + } + sc.write2File(outFile.getAbsolutePath(), "Turtle"); + // System.out.println("Category:" + sc.getCategory()); + } + +} Index: /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/InstanceLink.java =================================================================== --- /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/InstanceLink.java (revision 123) +++ /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/InstanceLink.java (revision 123) @@ -0,0 +1,122 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.util.HashSet; + +/** + * 繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｸ縲√≠繧九＞縺ｯ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺九ｉ縺ｮ1繧ｹ繝�ャ繝励Μ繝ｳ繧ｯ繧定ｨ倩ｿｰ縺吶ｋ + * @author Norio KOBAYASHI + * @since 28.01.2014 + * @version 29.01.2014 + */ +public class InstanceLink { + + private String propertyURI = null; + private String[] linkedClassURIs = null; + private String linkedInstanceURI = null; + private Direction direction = null; + + + /** + * 繝励Ο繝代ユ繧｣URI縲√Μ繝ｳ繧ｯ蜈茨ｼ亥��峨う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縲√Μ繝ｳ繧ｯ縺ｮ蜷代″繧剃ｸ弱∴繧区ｧ区�蟄� + * + * 繝ｪ繝ｳ繧ｯ蜈�(蜈� 繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｫ縺､縺�※縺ｯ縲√◎繧後′螻槭＠縺ｦ縺�ｋ縺吶∋縺ｦ縺ｮ繧ｯ繝ｩ繧ｹ繧ゆｸ弱∴繧� + * + * @param propertyURI縲繝励Ο繝代ユ繧｣縺ｮURI + * @param linkedInstanceURI縲繝ｪ繝ｳ繧ｯ縺ｮ荳ｻ隱槭√√≠繧九＞縺ｯ繝ｪ繝ｳ繧ｯ縺ｮ逶ｮ逧�ｪ槭→縺ｪ縺｣縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI + * @param linkedClassURIs縲linkedInstanceURI縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺悟ｱ槭＠縺ｦ縺�ｋ縺吶∋縺ｦ縺ｮ繧ｯ繝ｩ繧ｹ縺ｮURI縺ｮ驟榊� + * @param direction 繝励Ο繝代ユ繧｣縺ｮ蜷代″縲〕inkedClassURI縺ｮ繧ｯ繝ｩ繧ｹ縺後Μ繝ｳ繧ｯ蜈医↓縺ｪ縺｣縺ｦ縺�ｋ縺ｨ縺阪�Direction.forward,繝ｪ繝ｳ繧ｯ蜈�↓縺ｪ縺｣縺ｦ縺�ｋ縺ｨ縺阪�Direction.reverse, 縺昴ｌ繧我ｸ｡譁ｹ縺ｮ譎ゅ�Direction.both繧呈欠螳壹☆繧� + * @throws Exception + * @since 28.01.2014 + */ + public InstanceLink(String propertyURI, String linkedInstanceURI, String[] linkedClassURIs, Direction direction){ + this.propertyURI = propertyURI; + this.linkedInstanceURI = linkedInstanceURI; + this.linkedClassURIs = linkedClassURIs; + this.direction = direction; + } + + + /** + * linkedInstanceURI縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺悟ｱ槭＠縺ｦ縺�ｋ繧ｯ繝ｩ繧ｹ繧剃ｸ縺､霑ｽ蜉縺吶ｋ + * + * @param classURI縲霑ｽ蜉縺吶ｋlinkedInstanceURI縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺悟ｱ槭＠縺ｦ縺�ｋ繧ｯ繝ｩ繧ｹ縺ｮURI + * @throws Exception + * @since 28.01.2014 + */ + public void addLinkedClassURI(String classURI){ + if( linkedClassURIs == null || linkedClassURIs.length == 0 ){ + linkedClassURIs = new String[]{classURI}; + }else{ + HashSet hSet = new HashSet(); + for(String clsURI: linkedClassURIs){ + hSet.add(clsURI); + } + hSet.add(classURI); + linkedClassURIs = hSet.toArray(new String[0]); + } + } + + /** + * 譁�ｭ怜�陦ｨ險倥ｒ蜿門ｾ励☆繧� + * + * @since 28.01.2014 + */ + public String toString(){ + StringBuffer sb = new StringBuffer(); + sb.append(propertyURI); + if( direction == Direction.forward ){ + sb.append(" --> "); + }else{ + if( direction == Direction.reverse ){ + sb.append(" <-- "); + }else{ + sb.append(" <-> "); + } + } + sb.append(linkedInstanceURI); + sb.append(" rdf:type ["); + if( linkedClassURIs != null ){ + for( int i = 0; i < linkedClassURIs.length; i++ ) { + if( i != 0 ) { + sb.append(", "); + } + sb.append(linkedClassURIs[i]); + } + } + sb.append("]"); + return sb.toString(); + } + + public String getPropertyURI() { + return propertyURI; + } + public void setPropertyURI(String propertyURI) { + this.propertyURI = propertyURI; + } + public String[] getLinkedClassURIs() { + return linkedClassURIs; + } + public void setLinkedClassURIs(String[] linkedClassURIs) { + this.linkedClassURIs = linkedClassURIs; + } + public Direction getDirection() { + return direction; + } + public void setDirection(Direction direction) { + this.direction = direction; + } + + public String getLinkedInstanceURI() { + return linkedInstanceURI; + } + + public void setLinkedInstanceURI(String linkedInstanceURI) { + this.linkedInstanceURI = linkedInstanceURI; + } + + // private String[] propertyDomainClassURIs = null; + // private String[] propertyRangeClassURIs = null; + + + +} Index: /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/ClassLink.java =================================================================== --- /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/ClassLink.java (revision 123) +++ /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/ClassLink.java (revision 123) @@ -0,0 +1,255 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import org.json.JSONException; +import org.json.JSONObject; + +/** + * 繧ｯ繝ｩ繧ｹ縺ｸ縲√≠繧九＞縺ｯ繧ｯ繝ｩ繧ｹ縺九ｉ縺ｮ1繧ｹ繝�ャ繝励Μ繝ｳ繧ｯ繧定ｨ倩ｿｰ縺吶ｋ + * @author Norio KOBAYASHI + * @since 28.01.2014 + * @version 29.01.2014 + */ +public class ClassLink { + + private String propertyURI = null; + private String linkedClassURI = null; + private String linkedLiteralDatatypeURI = null; + private Direction direction = null; + private int numOfLinks = 0; + private int numOfLinkedInstances = 0; + private int numOfOriginInstances = 0; + private int numOfOriginClassInstances = 0; + private int numOfLinkedClassInstances = 0; + private boolean domainClassLimitedQ = false; + private boolean rangeClassLimitedQ = false; + + + /** + * 繝励Ο繝代ユ繧｣URI縲√Μ繝ｳ繧ｯ蜈茨ｼ亥��峨け繝ｩ繧ｹ縲√Μ繝ｳ繧ｯ縺ｮ蜷代″繧剃ｸ弱∴繧区ｧ区�蟄� + * + * @param propertyURI縲繝励Ο繝代ユ繧｣縺ｮURI + * @param linkedClassURI縲繝ｪ繝ｳ繧ｯ縺ｮ荳ｻ隱槭√√≠繧九＞縺ｯ繝ｪ繝ｳ繧ｯ縺ｮ逶ｮ逧�ｪ槭→縺ｪ縺｣縺ｦ縺�ｋ繧ｯ繝ｩ繧ｹ縺ｮURI + * @param direction 繝励Ο繝代ユ繧｣縺ｮ蜷代″縲〕inkedClassURI縺ｮ繧ｯ繝ｩ繧ｹ縺後Μ繝ｳ繧ｯ蜈医↓縺ｪ縺｣縺ｦ縺�ｋ縺ｨ縺阪�Direction.forward,繝ｪ繝ｳ繧ｯ蜈�↓縺ｪ縺｣縺ｦ縺�ｋ縺ｨ縺阪�Direction.reverse, 縺昴ｌ繧我ｸ｡譁ｹ縺ｮ譎ゅ�Direction.both繧呈欠螳壹☆繧� + * @param numOfLinks 蠖楢ｩｲ繝励Ο繝代ユ繧｣縺ｧ荳｡遶ｯ繧ｯ繝ｩ繧ｹ縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ蜷悟｣ｫ繧偵▽縺ｪ縺�〒縺�ｋ繝ｪ繝ｳ繧ｯ謨ｰ�医ヨ繝ｪ繝励Ν謨ｰ�� + * @throws Exception + * @since 28.01.2014 + */ + public ClassLink(String propertyURI, String linkedClassURI, String linkedLiteralDatatypeURI, Direction direction, + int numLinks, int numOfOriginInstances, int numOfLinkedInstances, + int numOfOriginClassInstances, int numofLinkedClassInstances, + boolean domainClassLimitedQ, boolean rangeClassLimitedQ){ + this.propertyURI = propertyURI; + this.linkedClassURI = linkedClassURI; + this.linkedLiteralDatatypeURI = linkedLiteralDatatypeURI; + this.direction = direction; + this.numOfLinks = numLinks; + this.numOfLinkedInstances = numOfLinkedInstances; + this.numOfOriginInstances = numOfOriginInstances; + this.numOfOriginClassInstances = numOfOriginClassInstances; + this.numOfLinkedClassInstances = numofLinkedClassInstances; + this.domainClassLimitedQ = domainClassLimitedQ; + this.rangeClassLimitedQ = rangeClassLimitedQ; + } + + + public JSONObject toJSON() throws JSONException{ + JSONObject obj = new JSONObject(); + if( propertyURI != null ) { + obj.put("propertyURI", propertyURI); + } + if( linkedClassURI != null ){ + obj.put("linkedClassURI", linkedClassURI); + } + if( linkedLiteralDatatypeURI != null ){ + obj.put("linkedLiteralDatatypeURI", linkedLiteralDatatypeURI); + } + obj.put("numOfLinks", numOfLinks); + obj.put("numOfLinkedInstances", numOfLinkedInstances); + obj.put("numOfOriginInstances", numOfOriginInstances); + obj.put("numOfOriginClassInstances", numOfOriginClassInstances); + obj.put("numOfLinkedClassInstances", numOfLinkedClassInstances); + return obj; + } + + public String toJSONString2() { + String json_str ="{"; + + if( propertyURI != null ) { + json_str+="\"propertyURI\":"+"\""+propertyURI+"\","; + } + else{ + json_str+="\"propertyURI\":"+"\"propertyURI\","; + } + if( linkedClassURI != null ){ + json_str+="\"linkedClassURI\":"+"\""+linkedClassURI+"\","; + } + else{ + json_str+="\"linkedClassURI\":"+"\"linkedClassURI\","; + } + if( linkedLiteralDatatypeURI != null ){ + json_str+="\"linkedLiteralDatatypeURI\":"+"\""+linkedLiteralDatatypeURI+"\""; + } + else{ + json_str+="\"linkedLiteralDatatypeURI\":"+"\"linkedLiteralDatatypeURI\""; + } + + //json_str+="\"numOfLinks\":"+"\""+numOfLinks+"\","; + //json_str+="\"numOfLinkedInstances\":"+"\""+numOfLinkedInstances+"\","; + //json_str+="\"numOfOriginInstances\":"+"\""+numOfOriginInstances+"\","; + //json_str+="\"numOfOriginClassInstances\":"+"\""+numOfOriginClassInstances+"\","; + //json_str+="\"numOfLinkedClassInstances\":"+"\""+numOfLinkedClassInstances+"\""; + + json_str+="}"; + + return json_str; + } + + + public int getNumOfLinks() { + return numOfLinks; + } + + + + + public void setNumOfLinks(int numOfLinks) { + this.numOfLinks = numOfLinks; + } + + + + + /** + * 譁�ｭ怜�陦ｨ險倥ｒ蜿門ｾ励☆繧� + * + * @since 28.01.2014 + */ + public String toString(){ + StringBuffer sb = new StringBuffer(); + sb.append(propertyURI); + if( direction == Direction.forward ){ + sb.append(" --> "); + }else{ + if( direction == Direction.reverse ){ + sb.append(" <-- "); + }else{ + sb.append(" <-> "); + } + } + sb.append(linkedClassURI); + sb.append(" ["); + sb.append(numOfOriginClassInstances); + sb.append("/"); + sb.append(numOfOriginInstances); + sb.append("]縲---"); + + + sb.append(" ["); + sb.append(numOfLinks); + sb.append("] --->"); + + sb.append(" ["); + sb.append(numOfLinkedClassInstances); + sb.append("/"); + sb.append(numOfLinkedInstances); + sb.append("]"); + return sb.toString(); + } + + public String getPropertyURI() { + return propertyURI; + } + public void setPropertyURI(String propertyURI) { + this.propertyURI = propertyURI; + } + public String getLinkedClassURI() { + return linkedClassURI; + } + public void setLinkedClassURI(String linkedClassURI) { + this.linkedClassURI = linkedClassURI; + } + public Direction getDirection() { + return direction; + } + public void setDirection(Direction direction) { + this.direction = direction; + } + + public final int getNumOfLinkedInstances() { + return numOfLinkedInstances; + } + + public final void setNumOfLinkedInstances(int numOfLinkedInstances) { + this.numOfLinkedInstances = numOfLinkedInstances; + } + + + + + public final boolean isDomainClassLimitedQ() { + return domainClassLimitedQ; + } + + + public final boolean isRangeClassLimitedQ() { + return rangeClassLimitedQ; + } + + + public final int getNumOfOriginInstances() { + return numOfOriginInstances; + } + + + public final void setNumOfOriginInstances(int numOfOriginInstances) { + this.numOfOriginInstances = numOfOriginInstances; + } + + + public final int getNumOfOriginClassInstances() { + return numOfOriginClassInstances; + } + + + public final void setNumOfOriginClassInstances(int numOfOriginClassInstances) { + this.numOfOriginClassInstances = numOfOriginClassInstances; + } + + + public final int getNumOfLinkedClassInstances() { + return numOfLinkedClassInstances; + } + + + public final void setNumOfLinkedClassInstances(int numOfLinkedClassInstances) { + this.numOfLinkedClassInstances = numOfLinkedClassInstances; + } + + + public final String getLinkedLiteralDatatypeURI() { + return linkedLiteralDatatypeURI; + } + + + public final void setLinkedLiteralDatatypeURI(String linkedLiteralDatatypeURI) { + this.linkedLiteralDatatypeURI = linkedLiteralDatatypeURI; + } + + + public final void setDomainClassLimitedQ(boolean domainClassLimitedQ) { + this.domainClassLimitedQ = domainClassLimitedQ; + } + + + public final void setRangeClassLimitedQ(boolean rangeClassLimitedQ) { + this.rangeClassLimitedQ = rangeClassLimitedQ; + } + + + + // private String[] propertyDomainClassURIs = null; + // private String[] propertyRangeClassURIs = null; + + + +} Index: /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/AcquiredStructureAnalyzer.java =================================================================== --- /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/AcquiredStructureAnalyzer.java (revision 123) +++ /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/AcquiredStructureAnalyzer.java (revision 123) @@ -0,0 +1,423 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.util.ArrayList; +import java.util.HashMap; + +import jp.riken.accc.db.rdf.crawler.dataStructure.sparql.JenaModelGenerator; + +import com.hp.hpl.jena.query.Query; +import com.hp.hpl.jena.query.QueryExecution; +import com.hp.hpl.jena.query.QueryExecutionFactory; +import com.hp.hpl.jena.query.QueryFactory; +import com.hp.hpl.jena.query.QuerySolution; +import com.hp.hpl.jena.query.ResultSet; +import com.hp.hpl.jena.rdf.model.Literal; +import com.hp.hpl.jena.rdf.model.Model; +import com.hp.hpl.jena.rdf.model.Property; +import com.hp.hpl.jena.rdf.model.Resource; + +//public class OWLQueryBuilderForCrawlerImpl implements OWLQueryBuilder { +public class AcquiredStructureAnalyzer implements RDFSchemaAnalyzer { + + private Model model = null; + private String endpointURI = null; + private String[] graphURIs = null; + + public String getEndpointURI(){ + return endpointURI; + } + + public String[] getGraphURIs(){ + return graphURIs; + } + + + public static void main(String[] args) throws Exception{ + JenaModelGenerator jmGene = new JenaModelGenerator("c:\\cdata\\allie.ttl"); + AcquiredStructureAnalyzer impl + = new AcquiredStructureAnalyzer(jmGene.getEndpointURI(), jmGene.getGraphURIs(), jmGene.getModel()); + System.out.println("--------------------------"); + SClass[] scs = impl.getOWLClasses(null, null, null, true); + System.out.println("list classes:---------------"); + for(SClass sc: scs){ + System.out.println(sc.toString()); + } + System.out.println("--------------------------"); + + ClassLink[] cls = impl.getNextClass(null,"http://purl.org/allie/ontology/201108#ShortForm",100,true ); + for(ClassLink cl: cls){ + System.out.println(cl.toString()); + } + System.out.println("--------------------------"); + + } + + + public AcquiredStructureAnalyzer(String endpointURI, String[] graphURIs, Model model){ + this.model = model; + this.endpointURI = endpointURI; + this.graphURIs = graphURIs; + } + + private String[] filterGraphURIs(String[] orgGraphURIs){ + // TODO + return graphURIs; + } + + + public SClass[] listClasses(String[] graphURIs, boolean countInstances) throws Exception{ + return getOWLClasses(graphURIs, null, null, countInstances); + } + + + + + public SClass[] getOWLClasses(String[] graphURIs, String[] keywords, String language, boolean countInstances) throws Exception{ + String[] targetGraphURIs = filterGraphURIs(graphURIs); + + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?c ?pLabel ?numOfInstances\n"); +// if (targetGraphURIs != null) { +// for (String graphURI : targetGraphURIs) { +// queryStr.append("FROM <"); +// queryStr.append(graphURI); +// queryStr.append(">\n"); +// } +// } + queryStr.append("WHERE{\n"); + queryStr.append(" ?c rdf:type rdfs:Class. \n"); + queryStr.append(" ?c ?numOfInstances. \n"); + queryStr.append(" OPTIONAL{ ?c rdfs:label ?pLabel. }\n"); + + if (keywords != null && keywords.length != 0) { + + queryStr.append(" ?c rdfs:label "); + queryStr.append("?keywords").append(".\n"); + queryStr.append(" filter((LANG(?keywords) = \'").append(language); + queryStr.append("\') && \n ("); + + for (int i = 0; i < keywords.length; i++) { + if (i > 0) + queryStr.append(" || \n "); + + queryStr.append("regex(str(").append("?keywords") + .append("),\""); + queryStr.append(keywords[i]); + queryStr.append("\", \"i\" )"); + + } + queryStr.append("))\n"); + + } + queryStr.append("}"); + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + + QueryExecution qexec = null; + ResultSet results = null; + try { +// long start = System.currentTimeMillis(); + qexec = QueryExecutionFactory.create(query, model); + results = qexec.execSelect(); +// long end = System.currentTimeMillis(); +// System.out.println("EXEC TIME: " + (end - start)); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + HashMap classMap = new HashMap(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource res = sol.getResource("c"); + if (res != null && res.getURI() != null) { + String uri = res.getURI(); + int numOfInstances = 0; + if (countInstances) { + numOfInstances = sol.getLiteral("numOfInstances").getInt(); + } // + Literal labelLiteral = sol.getLiteral("pLabel"); + SClass sClass = null; + if (classMap.containsKey(uri)) { + sClass = classMap.get(uri); + } else { + sClass = new SClass(uri, null, numOfInstances); + classMap.put(uri, sClass); + } + if (labelLiteral != null) { + String label = labelLiteral.getString(); + String lang = labelLiteral.getLanguage(); + sClass.addLabel(new Label(label, lang)); + } + } + } + qexec.close(); + return classMap.values().toArray(new SClass[0]); + } + +/* + + public Instance[] getInstances(String[] graphURIs, String keyword) throws Exception; +*/ + + + public ClassLink[] getNextClass(String[] graphURIs, String originClass, int limit, boolean countLinks) throws Exception{ + String[] targetGraphURIs = filterGraphURIs(graphURIs); + + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + + // SELECT + queryStr.append("SELECT DISTINCT ?indPropCat ?c ?dat ?d ?p ?numLnkInsStart ?numLnkInsEnd ?numInsDom ?numInsRan ?numTriples ?isStartClsLim ?isEndClsLim\n"); + +// if (targetGraphURIs != null) { +// for (String graphURI : targetGraphURIs) { +// queryStr.append("FROM <"); +// queryStr.append(graphURI); +// queryStr.append(">\n"); +// } +// } + + queryStr.append("WHERE{\n"); + queryStr.append(" ?cr rdf:type . \n"); +// queryStr.append(" <" + originClass + "> ?numInsStart. \n"); + queryStr.append(" {"); + queryStr.append(" ?cr <" + originClass + ">. \n"); + queryStr.append(" ?cr ?c. \n"); + queryStr.append(" ?cr ?p. \n"); + queryStr.append(" ?cr ?numTriples. \n"); + queryStr.append(" ?cr ?numLnkInsStart. \n"); + queryStr.append(" ?cr ?numLnkInsEnd. \n"); + queryStr.append(" ?cr ?isStartClsLim. \n"); + queryStr.append(" ?cr ?isEndClsLim. \n"); + queryStr.append("}\n"); + queryStr.append(" UNION\n"); + queryStr.append(" {"); + queryStr.append(" ?cr <" + originClass + ">. \n"); + queryStr.append(" ?cr ?dat. \n"); + queryStr.append(" ?cr ?p. \n"); + queryStr.append(" ?cr ?numTriples. \n"); + queryStr.append(" ?cr ?numLnkInsStart. \n"); + queryStr.append(" ?cr ?numLnkInsEnd. \n"); + queryStr.append(" ?cr ?isStartClsLim. \n"); + queryStr.append(" ?cr ?isEndClsLim. \n"); + queryStr.append("}\n"); + queryStr.append(" UNION\n"); + queryStr.append(" {"); + queryStr.append(" ?cr <" + originClass + ">. \n"); + queryStr.append(" ?cr ?d. \n"); + queryStr.append(" ?cr ?p. \n"); + queryStr.append(" ?cr ?numTriples.\n"); + queryStr.append(" ?cr ?numLnkInsEnd. \n"); + queryStr.append(" ?cr ?numLnkInsStart. \n"); + queryStr.append(" ?cr ?isEndClsLim. \n"); + queryStr.append(" ?cr ?isStartClsLim. \n"); + queryStr.append("}\n"); + + queryStr.append(" ?pp rdf:type . \n"); + queryStr.append(" ?pp ?p. \n"); + queryStr.append(" ?pp ?indPropCat. \n"); + queryStr.append(" ?pp ?numInsDom. \n"); + queryStr.append(" ?pp ?numInsRan \n"); + + queryStr.append("}\n"); + + + if (limit > 0) { + queryStr.append("limit "); + queryStr.append(limit); + queryStr.append("\n"); + } + +// System.out.println("getNextClasses SPARQL Query: "); +// System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = null; + ResultSet results = null; + try { + long start = System.currentTimeMillis(); + qexec = QueryExecutionFactory.create(query, model); + results = qexec.execSelect(); + long end = System.currentTimeMillis(); + System.out.println("EXEC TIME: " + (end - start)); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + ArrayList solCLs = new ArrayList(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource pro = sol.getResource("p"); + String clsURI = null; + String datURI = null; + if (pro != null) { + int indPropCat = 4; + Literal indPropCatLit = sol.getLiteral("indPropCat"); + if( indPropCatLit != null ){ + indPropCat = indPropCatLit.getInt(); + } + if( indPropCat < 4 ) { + String proURI = pro.getURI(); + Resource ccls = sol.getResource("c"); + Resource dcls = sol.getResource("d"); + Resource dat = sol.getResource("dat"); + Direction direction = null; + if(ccls != null && dcls == null ){ + // direction forward + direction = Direction.forward; + clsURI = ccls.getURI(); + }else{ + if( ccls == null && dcls != null ){ + direction = Direction.reverse; + clsURI = dcls.getURI(); + }else{ + if( ccls == null && dat != null && dcls == null ){ + clsURI = null; + direction = Direction.forward; + datURI = dat.getURI(); + } + } + } + + + int numTriples = 0; + Literal numTriplesLit = sol.getLiteral("numTriples"); + if( numTriplesLit != null ){ + numTriples = numTriplesLit.getInt(); + } + + int numLnkInsStart = 0; + Literal numInsStartLit = sol.getLiteral("numLnkInsStart"); + if( numInsStartLit != null ){ + numLnkInsStart = numInsStartLit.getInt(); + } + int numLnkInsEnd = 0; + Literal numInsEndLit = sol.getLiteral("numLnkInsEnd"); + if( numInsEndLit != null ){ + numLnkInsEnd = numInsEndLit.getInt(); + } + + int numInsDom = 0; + Literal numInsDomLit = sol.getLiteral("numInsDom"); + if( numInsDomLit != null ){ + numInsDom = numInsDomLit.getInt(); + } + int numInsRan = 0; + Literal numInsRanLit = sol.getLiteral("numInsRan"); + if( numInsRanLit != null ){ + numInsRan = numInsRanLit.getInt(); + } + + boolean isStartClsLim = false; + Literal isStartClsLimLit = sol.getLiteral("isStartClsLim"); + if( isStartClsLimLit != null ){ + isStartClsLim = isStartClsLimLit.getBoolean(); + } + boolean isEndClsLim = false; + Literal isEndClsLimLit = sol.getLiteral("isEndClsLim"); + if( isEndClsLimLit != null ){ + isEndClsLim = isEndClsLimLit.getBoolean(); + } + + ClassLink cl = new ClassLink(proURI, clsURI, datURI, direction, + numTriples, numInsDom, numInsRan, numLnkInsStart, numLnkInsEnd, isStartClsLim, isEndClsLim); + solCLs.add(cl); + + } + } + } + qexec.close(); + return solCLs.toArray(new ClassLink[0]); + } + + + + /* + + public ClassLink[] getNextClassViaInstanceLink(String[] graphURIs, String originClass, int limit) throws Exception; + + public Path[] getPaths(String startClass, String endClass, int mode, boolean countLinks) throws Exception; + + public String createSPARQL(Path path) throws Exception; + + InstanceLink[] getNextInstancesViaInstanceLink(String[] graphURIs, String originInstance, + int limit) throws Exception; +*/ + + public LabelMap[] getLabels(String[] graphURIs, String[] resourceURIs, + String language) throws Exception { + if (resourceURIs == null || resourceURIs.length == 0) { + return new LabelMap[0]; + } + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?res ?label \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + queryStr.append(" ?res rdfs:label ?label.\n"); + queryStr.append(" FILTER(?res IN ("); + boolean f = false; + for (String resourceURI : resourceURIs) { + if (f) { + queryStr.append(", "); + } + f = true; + queryStr.append("<"); + queryStr.append(resourceURI); + queryStr.append(">"); + } + queryStr.append("))\n"); + queryStr.append("}"); + +// System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.create(query, model); + + ResultSet results = qexec.execSelect(); + HashMap lMap = new HashMap(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + String uri = sol.getResource("res").getURI(); + Literal literal = sol.getLiteral("label"); + if (literal != null) { + String label = literal.getString(); + String lang = literal.getLanguage(); + if (language != null && language.equals(lang)) { + Label lbl = new Label(label, lang); + if (lMap.containsKey(uri)) { + LabelMap lm = lMap.get(uri); + lm.addLabel(lbl); + } else { + LabelMap lm = new LabelMap(uri, new Label[] { lbl }); + lMap.put(uri, lm); + } + } + } + } + return lMap.values().toArray(new LabelMap[0]); + } + +/* + public ClassLink[] countLinks(String[] graphURIs, String startClassURI, ClassLink[] classLinks) throws Exception; + public SClass[] countInstances(String[] graphURIs, SClass[] classes) throws Exception; + +*/ + +} Index: /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLClassSearcherImpl.java =================================================================== --- /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLClassSearcherImpl.java (revision 123) +++ /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/OWLClassSearcherImpl.java (revision 123) @@ -0,0 +1,14 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +public class OWLClassSearcherImpl implements OWLClassSearcher { + + public SClass[] keywordSearch(String[] keywords) throws Exception{ + return null; + } + + public SClass[] listClasses() throws Exception{ + return null; + } + + +} Index: /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/EndpointAnalyzer.java =================================================================== --- /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/EndpointAnalyzer.java (revision 123) +++ /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/EndpointAnalyzer.java (revision 123) @@ -0,0 +1,1163 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Set; + +import com.hp.hpl.jena.query.Query; +import com.hp.hpl.jena.query.QueryExecution; +import com.hp.hpl.jena.query.QueryExecutionFactory; +import com.hp.hpl.jena.query.QueryFactory; +import com.hp.hpl.jena.query.QuerySolution; +import com.hp.hpl.jena.query.ResultSet; +import com.hp.hpl.jena.rdf.model.Literal; +import com.hp.hpl.jena.rdf.model.Resource; + +/** + * 繧ｯ繧ｨ繝ｪ繧堤函謌舌☆繧九◆繧√�讖溯�繧呈署萓帙☆繧区ｸ繧ｯ繝ｩ繧ｹ + * + * @author Norio KOBAYASHI + * @since 28.01.2014 + * @version 29.01.2014 + */ +public class EndpointAnalyzer implements RDFSchemaAnalyzer { + + // private Model model = null; + private String endpointURI = null; + + /** + * 繧｢繧ｯ繧ｻ繧ｹ縺吶ｋSPARQL endpoint縺ｮURI繧呈欠螳壹☆繧区ｧ区�蟄� + * + * @param endpointURI + * 縲繧｢繧ｯ繧ｻ繧ｹ縺吶ｋSPARQL endpoint縺ｮURI + * @throws Exception + * @since 28.01.2014 + */ + public EndpointAnalyzer(String endpointURI) { + this.endpointURI = endpointURI; + } + + /** + * 繝�せ繝医↓菴ｿ逕ｨ縺吶ｋmain繝｡繧ｽ繝�ラ + * + * 繧ｯ繧ｨ繝ｪ繝薙Ν繝繝ｼ縺ｮ譛ｬ逡ｪ繝励Ο繧ｰ繝ｩ繝縺ｧ縺ｯ縺薙�繝｡繧ｽ繝�ラ縺ｯ菴ｿ逕ｨ縺励↑縺� + * + * + * @param args + * 菴ｿ逕ｨ縺励↑縺� + * @throws Exception + * @since 28.01.2014 + */ + public static void main(String[] args) throws Exception { + // String sparqlEndpoint = "http://dbpedia.org/sparql"; + String sparqlEndpoint = "http://lsd.dbcls.jp/sparql"; + // String keyword = "artiste"; + String[] keyword = { "Frequency", "Class" }; + String[] graphURIs = new String[0]; + + // keyword = null; + + EndpointAnalyzer builder = new EndpointAnalyzer(sparqlEndpoint); + + SClass[] clz = builder.getOWLClasses(null, keyword, "en", false); + if (clz != null) { + + for (SClass cls : clz) { + System.out.println(cls); + } + clz = builder.countInstances(null, clz); + for (SClass cls : clz) { + System.out.println(cls); + } + } + + /* + * clz = builder.listClasses(null, false); + * System.out.println(clz.length); for (SClass cls : clz) { + * System.out.println(cls); } + */ + + /* + * SClass[] clz = builder.getOWLClasses(graphURIs, keyword, false); for + * (SClass cls : clz) { System.out.println(cls); } clz = + * builder.countInstances(null, clz); for (SClass cls : clz) { + * System.out.println(cls); } + */ + + // builder.getOWLClasses(null, keyword, "en", false); + /* + * SClass[] clz = builder.getOWLClasses(graphURIs, keyword, false); for + * (SClass cls : clz) { System.out.println(cls); } clz = + * builder.countInstances(null, clz); for (SClass cls : clz) { + * System.out.println(cls); } + */ + + /* + * System.out.println("CLS"); + * + * String uri = + * "http://purl.jp/bio/10/lsd/ontology/201209#EnglishEntry"; + * + * ClassLink[] cls = null; try{ cls = builder.getNextClass(null, uri, + * 100, false); }catch(Exception ex) { ex.printStackTrace(); } + * + * System.out.println("Solutions: "); if (cls != null) { for (ClassLink + * cl : cls) { System.out.println(cl.toString()); } cls = + * builder.countLinks(null, uri, cls); for (ClassLink cl : cls) { + * System.out.println(cl.toString()); } } + */ + /* + * + * String uri = + * "http://purl.jp/bio/10/lsd/ontology/201209#EnglishEntry"; + * + * ClassLink[] cls = null; + * + * System.out.println("CLS-INS"); cls = null; try{ cls = + * builder.getNextClassViaInstanceLink(null, uri, 100); }catch(Exception + * ex){ ex.printStackTrace(); } if (cls != null) { for (ClassLink cl : + * cls) { System.out.println(cl.toString()); } } + */ + /* + * System.out.println("Instances"); Instance[] ins = + * builder.getInstances(null, "\"A.C. Reed\"@en"); if (ins != null) { + * for (Instance in : ins) { System.out.println(in.toString()); } } + */ + /* + * System.out.println("INS-INS"); ins = builder.getInstances(null, + * "\"A.C. Reed\"@en"); InstanceLink[] iLinks = + * builder.getNextInstancesViaInstanceLink(null, + * ins[0].getInstanceURI(), 100); + * + * if (iLinks != null) { for (InstanceLink in : iLinks) { + * System.out.println(in.toString()); } } + */ + } + + /** + * 譏守､ｺ逧�↓RDF縺ｧ譖ｸ縺九ｌ縺ｦ縺�ｋ繧ｯ繝ｩ繧ｹ繧貞叙蠕励☆繧� + * + * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧ｯ繝ｩ繧ｹ��dfs:Class�峨ｒ縺吶∋縺ｦ霑斐☆ + * + * + * @param graphURIs + * 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� (null繧�聞縺�縺ｮ驟榊�繧ょ庄) + * @param keyword + * ��ull繧�ｩｺ譁�ｭ励�荳榊庄�� + * @return 繧ｯ繝ｩ繧ｹURI縺ｮ驟榊� + * @throws Exception + * @since 28.01.2014 + */ + + public SClass[] getOWLClasses(String[] graphURIs, String[] keywords, + String language, + + boolean countInstances) throws Exception { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + if (countInstances) { + queryStr.append("SELECT DISTINCT ?c ?pLabel (COUNT(?i) AS ?numOfInstances)\n"); + } else { + queryStr.append("SELECT DISTINCT ?c ?pLabel \n"); + } + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + + // + queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n"); + // queryStr.append(" ?i rdf:type ?c.\n"); + + if (countInstances) { + queryStr.append(" ?c rdfs:label ?label.\n"); + } + queryStr.append(" ?c rdfs:label ?pLabel.\n"); + if (countInstances) { + queryStr.append(" ?i rdf:type ?c.\n"); + } + // queryStr.append(" ?c rdfs:label "); + // queryStr.append(keyword); + // queryStr.append("."); + + // TODO OR relationship between keywords + if (keywords != null && keywords.length != 0) { + + queryStr.append(" ?c rdfs:label "); + queryStr.append("?keywords").append(".\n"); + queryStr.append(" filter((LANG(?keywords) = \'").append(language); + queryStr.append("\') && \n ("); + + // (LANG(?keywords) = 'en') && + + for (int i = 0; i < keywords.length; i++) { + if (i > 0) + queryStr.append(" || \n "); + + queryStr.append("regex(str(").append("?keywords") + .append("),\""); + queryStr.append(keywords[i]); + queryStr.append("\", \"i\" )"); + + } + queryStr.append("))\n"); + + } + + if (countInstances) { + queryStr.append("} GROUP BY ?c ?pLabel"); + } else { + queryStr.append("}"); + } + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + + QueryExecution qexec = null; + ResultSet results = null; + try { + long start = System.currentTimeMillis(); + qexec = QueryExecutionFactory.sparqlService(endpointURI, query); + results = qexec.execSelect(); + long end = System.currentTimeMillis(); + System.out.println("EXEC TIME: " + (end - start)); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + HashMap classMap = new HashMap(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource res = sol.getResource("c"); + if (res != null) { + String uri = res.getURI(); + int numOfInstances = 0; + if (countInstances) { + numOfInstances = sol.getLiteral("numOfInstances").getInt(); + } // + System.out.println(numOfInstances); + Literal labelLiteral = sol.getLiteral("pLabel"); + SClass sClass = null; + if (classMap.containsKey(uri)) { + sClass = classMap.get(uri); + } else { + sClass = new SClass(uri, null, numOfInstances); + classMap.put(uri, sClass); + } + if (labelLiteral != null) { + String label = labelLiteral.getString(); + String lang = labelLiteral.getLanguage(); + sClass.addLabel(new Label(label, lang)); + } + } + } + qexec.close(); + return classMap.values().toArray(new SClass[0]); + + } + + public SClass[] listClasses(String[] graphURIs, boolean countInstances) + throws Exception { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + if (countInstances) { + queryStr.append("SELECT DISTINCT ?cls ?pLabel (COUNT(?i) AS ?numOfInstances)\n"); + } else { + queryStr.append("SELECT DISTINCT ?cls ?pLabel \n"); + } + + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + queryStr.append("\t{ ?cls rdf:type rdfs:Class. }\n"); + queryStr.append("\tUNION\n"); + queryStr.append("\t{ ?cls rdf:type owl:Class. }\n"); + queryStr.append("\tUNION\n"); + queryStr.append("\t{ [] rdfs:type ?cls. }\n"); + queryStr.append("\tUNION\n"); + queryStr.append("\t{ [] rdfs:domain ?cls. }\n"); + queryStr.append("\tUNION\n"); + queryStr.append("\t{ [] rdfs:range ?cls. }\n"); + queryStr.append("\tUNION\n"); + queryStr.append("\t{ ?cls rdfs:subclassOf []. }\n"); + queryStr.append("\t?cls rdfs:label ?pLabel.\n"); + if (countInstances) { + queryStr.append("\t?i rdf:type ?c.\n"); + } + if (countInstances) { + queryStr.append("} GROUP BY ?c ?pLabel"); + } else { + queryStr.append("}"); + } + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + + QueryExecution qexec = null; + ResultSet results = null; + try { + long start = System.currentTimeMillis(); + qexec = QueryExecutionFactory.sparqlService(endpointURI, query); + results = qexec.execSelect(); + long end = System.currentTimeMillis(); + System.out.println("EXEC TIME: " + (end - start)); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + HashMap classMap = new HashMap(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource res = sol.getResource("cls"); + if (res != null) { + String uri = res.getURI(); + int numOfInstances = 0; + if (countInstances) { + numOfInstances = sol.getLiteral("numOfInstances").getInt(); + } + // System.out.println(numOfInstances); + Literal labelLiteral = sol.getLiteral("pLabel"); + SClass sClass = null; + if (classMap.containsKey(uri)) { + sClass = classMap.get(uri); + } else { + sClass = new SClass(uri, null, numOfInstances); + classMap.put(uri, sClass); + } + if (labelLiteral != null) { + String label = labelLiteral.getString(); + String lang = labelLiteral.getLanguage(); + sClass.addLabel(new Label(label, lang)); + } + } + } + qexec.close(); + return classMap.values().toArray(new SClass[0]); + + } + + /** + * 縲繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧貞叙蠕励☆繧� + * + * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧偵☆縺ｹ縺ｦ霑斐☆ + * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + * + * + * @param graphURIs + * 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� (null繧�聞縺�縺ｮ驟榊�繧ょ庄) + * @param keyword + * ��ull繧�ｩｺ譁�ｭ励�荳榊庄�� + * @return 繧ｯ繝ｩ繧ｹURI縺ｮ驟榊� + * @throws Exception + * @since 28.01.2014 + */ + public Instance[] getInstances(String[] graphURIs, String keyword) + throws Exception { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?ins ?c \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + // queryStr.append(" {?c rdf:type rdfs:Class} UNION {?c rdf:type owl:Class}\n"); + + queryStr.append(" ?ins rdf:type ?c.\n"); + queryStr.append(" ?ins rdfs:label "); + queryStr.append(keyword); + queryStr.append(".\n"); + queryStr.append(" FILTER (?c != rdf:Property)"); + queryStr.append("}"); + + // System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI, + query); + + ResultSet results = qexec.execSelect(); + HashMap> instanceMap = new HashMap>(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource cls = sol.getResource("c"); + Resource ins = sol.getResource("ins"); + String clsURI = cls.getURI(); + String insURI = ins.getURI(); + if (instanceMap.containsKey(insURI)) { + HashSet classes = instanceMap.get(insURI); + classes.add(clsURI); + } else { + HashSet classes = new HashSet(); + instanceMap.put(insURI, classes); + classes.add(clsURI); + } + } + qexec.close(); + Set keySet = instanceMap.keySet(); + ArrayList instanceList = new ArrayList(); + for (String key : keySet) { + Instance ins = new Instance(key, instanceMap.get(key).toArray( + new String[0])); + instanceList.add(ins); + } + return instanceList.toArray(new Instance[0]); + } + + /** + * 縲謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励∵�遉ｺ逧�↓險倩ｿｰ縺輔ｌ縺ｦ縺�ｋOWL縺ｮproperty蛻ｶ邏�ｒ隱ｿ縺ｹ縲√◎縺ｮproperty蛻ｶ邏�〒 + * 髢｢騾｣縺･縺代ｉ繧後※縺�ｋ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧� + * + * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + * + * + * + * @param graphURIs + * 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲(null繧�聞縺�縺ｮ驟榊�繧ょ庄) + * @param originClass + * 襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲��ull荳榊庄�� + * @param limit + * 隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧� + * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲� + * @throws Exception + * @since 28.01.2014 + */ + public ClassLink[] getNextClass(String[] graphURIs, String originClass, + int limit, boolean countLinks) throws Exception { + ClassLink[] cLinks = getNextClassSub(graphURIs, originClass, limit, + false); + if (countLinks) { + cLinks = countLinks(graphURIs, originClass, cLinks); + } + return cLinks; + } + + private ClassLink[] getNextClassSub(String[] graphURIs, String originClass, + int limit, boolean countLinks) throws Exception { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + + // SELECT + if (countLinks) { + 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"); + } else { + queryStr.append("SELECT DISTINCT ?p ?pDirection ?c \n"); + } + + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + // queryStr.append(" { ?c rdf:type rdfs:Class. }\n UNION\n { ?c rdf:type owl:Class. }\n"); + queryStr.append(" { ?p rdfs:domain <"); + queryStr.append(originClass); + queryStr.append(">.\n ?p rdfs:range ?c.\n"); + + if (countLinks) { + queryStr.append(" ?o ?p ?s."); + } else { + queryStr.append("filter(exists{\n"); + queryStr.append(" ?o rdf:type ?c.\n"); + queryStr.append(" ?s rdf:type <"); + queryStr.append(originClass); + queryStr.append(">.\n"); + queryStr.append(" ?s ?p ?o.})\n"); + } + + queryStr.append("}\n UNION\n"); + queryStr.append(" { ?p rdfs:range <"); + queryStr.append(originClass); + queryStr.append(">.\n"); + queryStr.append(" ?p rdfs:domain ?c.\n"); + + if (countLinks) { + queryStr.append(" ?s ?p ?o."); + } else { + queryStr.append("filter(exists{\n"); + queryStr.append(" ?s rdf:type ?c.\n"); + queryStr.append(" ?o rdf:type <"); + queryStr.append(originClass); + queryStr.append(">.\n"); + queryStr.append(" ?s ?p ?o.})\n"); + } + + queryStr.append("}\n"); + + queryStr.append(" ?p ?pDirection ?c.\n"); + + // queryStr.append(" ?s rdf:type ?c.\n"); + + if (countLinks) { + queryStr.append("}\nGROUP BY ?p ?pDirection ?c\n"); + } else { + queryStr.append("}\n"); + } + if (limit > 0) { + queryStr.append("limit "); + queryStr.append(limit); + queryStr.append("\n"); + } + + System.out.println("getNextClasses SPARQL Query: "); + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = null; + try { + qexec = QueryExecutionFactory.sparqlService(endpointURI, query); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + ResultSet results = null; + try { + long start = System.currentTimeMillis(); + results = qexec.execSelect(); + long end = System.currentTimeMillis(); + System.out.println("EXEC TIME: " + (end - start)); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + ArrayList solCLs = new ArrayList(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource pro = sol.getResource("p"); + if (pro != null) { + Resource cls = sol.getResource("c"); + Resource dir = sol.getResource("pDirection"); + String proURI = pro.getURI(); + String clsURI = cls.getURI(); + String dirURI = dir.getURI(); + + // System.out.println(pro.getURI() + " " + cls.getURI() + " " + + // dir.getURI()); + + Direction direction = null; + if (dirURI + .equals("http://www.w3.org/2000/01/rdf-schema#domain") + || dirURI.equals("rdfs:domain")) { + direction = Direction.reverse; + } + if (dirURI.equals("http://www.w3.org/2000/01/rdf-schema#range") + || dirURI.equals("rdfs:range")) { + if (direction != null) { + direction = Direction.both; + } else { + direction = Direction.forward; + } + } + // System.out.println(direction); + int numOfLinks = 0; + if (countLinks) { + numOfLinks = sol.getLiteral("numOfLinks").getInt(); + } + ClassLink cl = new ClassLink(proURI, clsURI, null,direction, + numOfLinks, 0, 0, 0, 0, true, true); + solCLs.add(cl); + } + } + qexec.close(); + return solCLs.toArray(new ClassLink[0]); + } + + /** + * 縲謖�ｮ壹＆繧後◆繧ｯ繝ｩ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励√◎縺ｮ繧ｯ繝ｩ繧ｹ縺ｫ螻槭＠縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励＠縲� + * 蜿門ｾ励＠縺溘う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧堤ｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧� + * + * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + * + * + * @param graphURIs + * 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲(null繧�聞縺�縺ｮ驟榊�繧ょ庄) + * @param originClass + * 襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI縲��ull荳榊庄�� + * @param limit + * 隗｣縺ｨ縺励※霑斐＆繧後ｋClassLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧� + * @return ClassLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲� + * @throws Exception + * @since 28.01.2014 + */ + public ClassLink[] getNextClassViaInstanceLink(String[] graphURIs, + String originClass, int limit) throws Exception { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + 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"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + queryStr.append(" ?ins rdf:type ?c.\n"); + queryStr.append(" ?insOrg rdf:type <"); + queryStr.append(originClass); + queryStr.append(">.\n"); + queryStr.append(" { ?ins ?pr ?insOrg. }\n UNION { ?insOrg ?pf ?ins. }\n"); + queryStr.append("}\n"); + queryStr.append("GROUP BY ?pf ?pr ?c\n"); + if (limit > 0) { + queryStr.append("limit "); + queryStr.append(limit); + queryStr.append("\n"); + } + + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI, + query); + + ResultSet results = null; + try { + long start = System.currentTimeMillis(); + results = qexec.execSelect(); + long end = System.currentTimeMillis(); + System.out.println("EXEC TIME: " + (end - start)); + } catch (Exception ex) { + ex.printStackTrace(); + throw ex; + } + + ArrayList solCLs = new ArrayList(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource proForward = sol.getResource("pf"); + Resource proReverse = sol.getResource("pr"); + Resource cls = sol.getResource("c"); + Direction direction = null; + String propURI = null; + int numOfLinks = 0; + int numOfLinkedInstances = 0; + int numOfOriginInstances = 0; + if (proForward != null) { + if (proReverse != null) { + numOfLinks = sol.getLiteral("numOfForwardLinks").getInt(); + numOfLinks += sol.getLiteral("numOfReverseLinks").getInt(); + numOfLinkedInstances = sol.getLiteral( + "numOfLinkedInstances").getInt(); + numOfOriginInstances = sol.getLiteral( + "numOfOriginInstances").getInt(); + direction = Direction.both; + } else { + numOfLinkedInstances = sol.getLiteral( + "numOfLinkedInstances").getInt(); + numOfOriginInstances = sol.getLiteral( + "numOfOriginInstances").getInt(); + numOfLinks = sol.getLiteral("numOfForwardLinks").getInt(); + direction = Direction.forward; + } + propURI = proForward.getURI(); + } else { + direction = Direction.reverse; + propURI = proReverse.getURI(); + numOfLinkedInstances = sol.getLiteral("numOfOriginInstances") + .getInt(); + numOfOriginInstances = sol.getLiteral("numOfLinkedInstances") + .getInt(); + numOfLinks = sol.getLiteral("numOfReverseLinks").getInt(); + } + String clsURI = cls.getURI(); + // System.out.println(propURI + " " + clsURI + " " + direction); + + ClassLink cl = new ClassLink(propURI, clsURI, null, direction, + numOfLinks, numOfOriginInstances, numOfLinkedInstances, 0, + 0, true, true); + solCLs.add(cl); + } + qexec.close(); + return solCLs.toArray(new ClassLink[0]); + } + +/* + public Path[] getPaths(String startClass, String endClass, int mode, + boolean countLinks) throws Exception { + OWLClassGraph graph = new OWLClassGraph(startClass, endClass); + // mode = 2 & countLinks = true are recommended + return graph.getPaths(this, mode, countLinks); + } + + public String createSPARQL(Path path) throws Exception { + return null; + } +*/ + + /* + * private String executeSelect(String sparqlQuery) throws Exception { + * HttpClient client = HttpClientBuilder.create().build(); HttpPost httppost + * = new HttpPost(endpointURI); httppost.setHeader("Content-Type", + * "application/x-www-form-urlencoded"); httppost.setHeader("Accept", + * "application/sparql-results+xml"); List nvpList = new + * ArrayList(); nvpList.add(new BasicNameValuePair("query", + * sparqlQuery)); // nvpList.add(new BasicNameValuePair("format", // + * outputFormat.getMime())); httppost.setEntity(new + * UrlEncodedFormEntity(nvpList, Charset .forName("UTF-8"))); HttpResponse + * response = client.execute(httppost); // + * System.out.println("[StatusLine] " + response.getStatusLine()); + * HttpEntity entity = response.getEntity(); String entityString = + * EntityUtils.toString(entity, "UTF-8"); return entityString; } + */ + + /** + * 縲謖�ｮ壹＆繧後◆繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧定ｵｷ轤ｹ縺ｨ縺励√◎縺ｮ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｫ繝ｪ繝ｳ繧ｯ縺悟ｼｵ繧峨ｌ縺ｦ縺�ｋ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ髮�粋繧貞叙蠕励☆繧九� + * 縲蜿門ｾ励＆繧後◆蜷�う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮ繧ｯ繝ｩ繧ｹ繧らｶｲ鄒�噪縺ｫ蜿門ｾ励☆繧� + * + * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + * + * + * @param graphURIs + * 縲讀懃ｴ｢蟇ｾ雎｡縺ｮgraph縺ｮURI驟榊� 縲(null繧�聞縺�縺ｮ驟榊�繧ょ庄) + * @param originInstance + * 襍ｷ轤ｹ縺ｨ縺ｪ繧九う繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI縲��ull荳榊庄�� + * @param limit + * 隗｣縺ｨ縺励※霑斐＆繧後ｋInstanceLink驟榊�縺ｮ髟ｷ縺輔�荳企剞蛟､繧呈欠螳壹☆繧九�荳企剞蛟､繧定ｨｭ螳壹＠縺ｪ縺�ｴ蜷医�0莉･荳九�蛟､繧呈欠螳壹☆繧� + * @return InstanceLink縺ｮ驟榊�縲ゅ％縺薙↓縺ｯ縲∝叙蠕励＆繧後◆繧ｯ繝ｩ繧ｹ縺ｨ髢｢菫ゅ▼縺代ｉ繧後※縺�ｋ繝励Ο繝代ユ繧｣縲�未菫ゅ�蜷代″縺悟性縺ｾ繧後ｋ縲� + * @throws Exception + * @since 28.01.2014 + */ + public InstanceLink[] getNextInstancesViaInstanceLink(String[] graphURIs, + String originInstance, int limit) throws Exception { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?pf ?pr ?ins ?c \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + // queryStr.append(" { ?c rdf:type rdfs:Class. }\n UNION\n { ?c rdf:type owl:Class. }\n"); + queryStr.append(" ?ins rdf:type ?c.\n"); + queryStr.append(" { ?ins ?pr <"); + queryStr.append(originInstance); + queryStr.append(">. }\n UNION { <"); + queryStr.append(originInstance); + queryStr.append("> ?pf ?ins. }\n"); + + queryStr.append(" FILTER (?c != rdf:Property)"); + + queryStr.append("}\n"); + if (limit > 0) { + queryStr.append("limit "); + queryStr.append(limit); + queryStr.append("\n"); + } + + // System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI, + query); + + ResultSet results = qexec.execSelect(); + HashMap insLinkMap = new HashMap(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + Resource proForward = sol.getResource("pf"); + Resource proReverse = sol.getResource("pr"); + Resource ins = sol.getResource("ins"); + Resource cls = sol.getResource("c"); + Direction direction = null; + String propURI = null; + if (proForward != null) { + if (proReverse != null) { + direction = Direction.both; + } else { + direction = Direction.forward; + } + propURI = proForward.getURI(); + } else { + direction = Direction.reverse; + propURI = proReverse.getURI(); + } + String clsURI = cls.getURI(); + String insURI = ins.getURI(); + String key = propURI + "\t" + insURI + "\t" + direction; + if (insLinkMap.containsKey(key)) { + InstanceLink insLink = insLinkMap.get(key); + insLink.addLinkedClassURI(clsURI); + } else { + InstanceLink insLink = new InstanceLink(propURI, insURI, + new String[] { clsURI }, direction); + insLinkMap.put(key, insLink); + } + } + qexec.close(); + Collection values = insLinkMap.values(); + return values.toArray(new InstanceLink[0]); + } + + public LabelMap[] getLabels(String[] graphURIs, String[] resourceURIs, + String language) throws Exception { + if (resourceURIs == null || resourceURIs.length == 0) { + return new LabelMap[0]; + } + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?res ?label \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + queryStr.append(" ?res rdfs:label ?label.\n"); + queryStr.append(" FILTER(?res IN ("); + boolean f = false; + for (String resourceURI : resourceURIs) { + if (f) { + queryStr.append(", "); + } + f = true; + queryStr.append("<"); + queryStr.append(resourceURI); + queryStr.append(">"); + } + queryStr.append("))\n"); + queryStr.append("}"); + + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI, + query); + + ResultSet results = qexec.execSelect(); + HashMap lMap = new HashMap(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + String uri = sol.getResource("res").getURI(); + Literal literal = sol.getLiteral("label"); + if (literal != null) { + String label = literal.getString(); + String lang = literal.getLanguage(); + if (language != null && language.equals(lang)) { + Label lbl = new Label(label, lang); + if (lMap.containsKey(uri)) { + LabelMap lm = lMap.get(uri); + lm.addLabel(lbl); + } else { + LabelMap lm = new LabelMap(uri, new Label[] { lbl }); + lMap.put(uri, lm); + } + } + } + } + return lMap.values().toArray(new LabelMap[0]); + } + + public ClassLink[] countLinks(String[] graphURIs, String startClassURI, + ClassLink[] classLinks) throws Exception { + if (classLinks == null || classLinks.length == 0) { + return new ClassLink[0]; + } + for (ClassLink classLink : classLinks) { + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + + queryStr.append("SELECT (COUNT(?os) AS ?numOfLinks) (COUNT(DISTINCT(?is)) AS ?numOfOriginInstances) (COUNT(DISTINCT(?os)) AS ?numOfLinkedInstances) \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + + queryStr.append("WHERE{\n"); + if (classLink.getDirection() == Direction.forward) { + queryStr.append("?is rdf:type <"); + queryStr.append(startClassURI); + queryStr.append(">.\n"); + queryStr.append("?os rdf:type <"); + queryStr.append(classLink.getLinkedClassURI()); + queryStr.append(">.\n"); + queryStr.append("?is <"); + queryStr.append(classLink.getPropertyURI()); + queryStr.append("> ?os.\n"); + queryStr.append("}"); + } else { + if (classLink.getDirection() == Direction.forward) { + queryStr.append("?os rdf:type <"); + queryStr.append(startClassURI); + queryStr.append(">.\n"); + queryStr.append("?is rdf:type <"); + queryStr.append(classLink.getLinkedClassURI()); + queryStr.append(">.\n"); + queryStr.append("?is <"); + queryStr.append(classLink.getPropertyURI()); + queryStr.append("> ?os.\n"); + queryStr.append("}"); + } else { + queryStr.append("?os rdf:type <"); + queryStr.append(startClassURI); + queryStr.append(">.\n"); + queryStr.append("?is rdf:type <"); + queryStr.append(classLink.getLinkedClassURI()); + queryStr.append(">.\n"); + queryStr.append("{?is <"); + queryStr.append(classLink.getPropertyURI()); + queryStr.append("> ?os.}\n"); + queryStr.append("UNION\n"); + queryStr.append("{?os <"); + queryStr.append(classLink.getPropertyURI()); + queryStr.append("> ?is.}\n"); + queryStr.append("}"); + } + } + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.sparqlService( + endpointURI, query); + + ResultSet results = qexec.execSelect(); + if (results.hasNext()) { + QuerySolution sol = results.next(); + Literal lit = sol.getLiteral("numOfLinks"); + if (lit != null) { + int numOfLinks = lit.getInt(); + classLink.setNumOfLinks(numOfLinks); + } + lit = sol.getLiteral("numOfLinkedInstances"); + if (lit != null) { + int numOfLinkedInstances = lit.getInt(); + classLink.setNumOfLinkedInstances(numOfLinkedInstances); + } + lit = sol.getLiteral("numOfOriginInstances"); + if (lit != null) { + int numOfOriginInstances = lit.getInt(); + classLink.setNumOfOriginInstances(numOfOriginInstances); + } + lit = sol.getLiteral("numOfOriginClassInstances"); + if (lit != null) { + int numOfOriginClassInstances = lit.getInt(); + classLink + .setNumOfOriginClassInstances(numOfOriginClassInstances); + } + lit = sol.getLiteral("numOfLinkedClassInstances"); + if (lit != null) { + int numOfLinkedClassInstances = lit.getInt(); + classLink + .setNumOfLinkedClassInstances(numOfLinkedClassInstances); + } + } + qexec.close(); + + // count instances + queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + + queryStr.append("SELECT (COUNT(?ics) AS ?numOfOriginClassInstances) \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + + queryStr.append("WHERE{\n"); + if (classLink.getDirection() == Direction.forward) { + queryStr.append("?ics rdf:type <"); + queryStr.append(startClassURI); + queryStr.append(">.\n"); + queryStr.append("}"); + } else { + if (classLink.getDirection() == Direction.forward) { + queryStr.append("?ics rdf:type <"); + queryStr.append(classLink.getLinkedClassURI()); + queryStr.append(">.\n"); + queryStr.append("}"); + } else { + queryStr.append("?ics rdf:type <"); + queryStr.append(classLink.getLinkedClassURI()); + queryStr.append(">.\n"); + queryStr.append("}"); + } + } + + System.out.println(queryStr.toString()); + + query = QueryFactory.create(queryStr.toString()); + qexec = QueryExecutionFactory.sparqlService(endpointURI, query); + + results = qexec.execSelect(); + if (results.hasNext()) { + QuerySolution sol = results.next(); + Literal lit = null; + lit = sol.getLiteral("numOfOriginClassInstances"); + if (lit != null) { + int numOfOriginClassInstances = lit.getInt(); + classLink + .setNumOfOriginClassInstances(numOfOriginClassInstances); + } + } + qexec.close(); + + // count instances + queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + + queryStr.append("SELECT (COUNT(?ocs) AS ?numOfLinkedClassInstances) \n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + + queryStr.append("WHERE{\n"); + if (classLink.getDirection() == Direction.forward) { + queryStr.append("?ocs rdf:type <"); + queryStr.append(classLink.getLinkedClassURI()); + queryStr.append(">.\n"); + queryStr.append("}"); + } else { + if (classLink.getDirection() == Direction.forward) { + queryStr.append("?ocs rdf:type <"); + queryStr.append(startClassURI); + queryStr.append(">.\n"); + queryStr.append("}"); + } else { + queryStr.append("?ocs rdf:type <"); + queryStr.append(startClassURI); + queryStr.append(">.\n"); + queryStr.append("}"); + } + } + + System.out.println(queryStr.toString()); + + query = QueryFactory.create(queryStr.toString()); + qexec = QueryExecutionFactory.sparqlService(endpointURI, query); + + results = qexec.execSelect(); + if (results.hasNext()) { + QuerySolution sol = results.next(); + Literal lit = null; + lit = sol.getLiteral("numOfLinkedClassInstances"); + if (lit != null) { + int numOfLinkedClassInstances = lit.getInt(); + classLink + .setNumOfLinkedClassInstances(numOfLinkedClassInstances); + } + } + qexec.close(); + + } + return classLinks; + } + + public SClass[] countInstances(String[] graphURIs, SClass[] classes) + throws Exception { + if (classes == null || classes.length == 0) { + return new SClass[0]; + } + HashMap classMap = new HashMap(); + for (SClass sc : classes) { + classMap.put(sc.getClassURI(), sc); + } + StringBuffer queryStr = new StringBuffer(); + queryStr.append("PREFIX owl: \n"); + queryStr.append("PREFIX rdfs: \n"); + queryStr.append("PREFIX rdf: \n"); + queryStr.append("SELECT DISTINCT ?cls (COUNT(?is) AS ?numOfInstances)\n"); + if (graphURIs != null) { + for (String graphURI : graphURIs) { + queryStr.append("FROM <"); + queryStr.append(graphURI); + queryStr.append(">\n"); + } + } + queryStr.append("WHERE{\n"); + queryStr.append(" ?is rdf:type ?cls.\n"); + queryStr.append(" FILTER(?cls IN ("); + boolean f = false; + Set clsSet = classMap.keySet(); + for (String clsURI : clsSet) { + if (f) { + queryStr.append(", "); + } + f = true; + queryStr.append("<"); + queryStr.append(clsURI); + queryStr.append(">"); + } + queryStr.append("))\n"); + queryStr.append("} GROUP BY ?cls"); + + System.out.println(queryStr.toString()); + + Query query = QueryFactory.create(queryStr.toString()); + QueryExecution qexec = QueryExecutionFactory.sparqlService(endpointURI, + query); + + ResultSet results = qexec.execSelect(); + for (; results.hasNext();) { + QuerySolution sol = results.next(); + String uri = sol.getResource("cls").getURI(); + SClass sc = classMap.get(uri); + Literal lit = sol.getLiteral("numOfInstances"); + if (lit != null) { + int numOfInstances = lit.getInt(); + sc.setNumOfInstances(numOfInstances); + } + } + qexec.close(); + + return classes; + } + +} Index: /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/SClass.java =================================================================== --- /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/SClass.java (revision 123) +++ /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/SClass.java (revision 123) @@ -0,0 +1,84 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.util.HashSet; + +public class SClass { + + private String classURI; + private int numOfInstances; + private HashSet labels; + + /** + * 繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI縺ｨ縺昴�繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺悟ｱ槭＠縺ｦ縺�ｋ縺吶∋縺ｦ縺ｮ繧ｯ繝ｩ繧ｹ繧剃ｸ弱∴繧区ｧ区�蟄� + * + * @param instanceURI + * 縲繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｮURI + * @param classURIs + * 縲蠖楢ｩｲ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺悟ｱ槭＠縺ｦ縺�ｋ縺吶∋縺ｦ縺ｮ繧ｯ繝ｩ繧ｹ縺ｮURI縺ｮ驟榊� + * @throws Exception + * @since 28.01.2014 + */ + public SClass(String classURI, Label[] labels, int numOfInstances) { + this.classURI = classURI; + this.numOfInstances = numOfInstances; + setLabels(labels); + } + + /** + * 譁�ｭ怜�陦ｨ險倥ｒ蜿門ｾ励☆繧� + * + * @since 28.01.2014 + */ + public String toString() { + StringBuffer sb = new StringBuffer(); + sb.append(classURI); + sb.append("["); + boolean f = false; + if (labels != null) { + for (Label label : labels) { + if (f) { + sb.append(", "); + } + f = true; + sb.append(label.toString()); + } + } + sb.append("], "); + sb.append(numOfInstances); + return sb.toString(); + } + + public final String getClassURI() { + return classURI; + } + + public final void setClassURI(String classURI) { + this.classURI = classURI; + } + + public final int getNumOfInstances() { + return numOfInstances; + } + + public final void setNumOfInstances(int numOfInstances) { + this.numOfInstances = numOfInstances; + } + + public final Label[] getLabels() { + return labels.toArray(new Label[0]); + } + + public final void setLabels(Label[] labelArrays) { + labels = new HashSet(); + if (labelArrays != null) { + for (Label label : labelArrays) { + labels.add(label); + } + } + } + + public void addLabel(Label label) { + labels.add(label); + } + +} Index: /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/QueryPathGenerator.java =================================================================== --- /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/QueryPathGenerator.java (revision 123) +++ /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/QueryPathGenerator.java (revision 123) @@ -0,0 +1,113 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ + +package org.biohackathon.SPARQLBuilder.OWL; + + +/** + * + * @author atsuko + */ + +public class QueryPathGenerator { + private String sparqlEndpoint = null; + private RDFSchemaAnalyzerFactory factory = null; + private RDFSchemaAnalyzer analyzer = null; + //private OWLClassGraph graph; + + private static final String CDIR = "cdata"; + + public static void main(String[] args){ + // For Test + String sp = "http://data.allie.dbcls.jp/sparql"; + String sc = "http://purl.org/allie/ontology/201108#ShortForm"; + String ec = "http://purl.org/allie/ontology/201108#LongForm"; + //String sp = "http://www.ebi.ac.uk/rdf/services/chembl/sparql"; + //String sc = "http://rdf.ebi.ac.uk/terms/chembl#Enzyme"; + //String ec = "http://rdf.ebi.ac.uk/terms/chembl#Activity"; + //String sp = "http://www.ebi.ac.uk/rdf/services/biosamples/sparql"; + //String sc = "http://rdf.ebi.ac.uk/terms/biosd/Sample"; + //String ec = "http://purl.obolibrary.org/obo/NCBITaxon_7955"; + //String sp = "http://www.ebi.ac.uk/rdf/services/biosamples/sparql"; + //String sc = "http://rdf.ebi.ac.uk/terms/biosd/Sample"; + //String ec = "http://purl.obolibrary.org/obo/NCBITaxon_7955"; + //String sp = "http://lsd.dbcls.jp/sparql"; + //String sc = "http://purl.jp/bio/10/lsd/ontology/201209#EnglishCode"; + //String ec = "http://purl.jp/bio/10/lsd/ontology/201209#JapaneseCode"; + //QueryPathGenerator qpg = new QueryPathGenerator(sp, "c:\\cdata"); + QueryPathGenerator qpg1 = new QueryPathGenerator(sp, "cdata/"); + //SClass[] cl = qpg.getClasses(null); + + long start1 = System.currentTimeMillis(); + Path[] path1 = qpg1.getPaths(sc, ec, false); + long end1 = System.currentTimeMillis(); + + QueryPathGenerator qpg2 = new QueryPathGenerator(sp, "ddata/"); + long start2 = System.currentTimeMillis(); + Path[] path2 = qpg2.getPaths(sc, ec, false); + long end2 = System.currentTimeMillis(); + System.out.println("TOTAL1:"); + System.out.println(end1 - start1); + System.out.println("TOTAL2:"); + System.out.println(end2 - start2); + + System.out.println(path1.length); + System.out.println(path2.length); + } + + public QueryPathGenerator(){ + factory = new RDFSchemaAnalyzerFactory(); + } + + public QueryPathGenerator(String sparqlEndpoint){ + factory = new RDFSchemaAnalyzerFactory(CDIR); + setSPARQLendpoint(sparqlEndpoint); + } + + public QueryPathGenerator(String sparqlEndpoint, String crawlFileName){ + factory = new RDFSchemaAnalyzerFactory(crawlFileName); + setSPARQLendpoint(sparqlEndpoint); + } + + public SClass[] getClasses(String keyword){ + String[] keywords = null; + if ( keyword != null ){ + if ( keyword.length() != 0 ){ + keywords = new String[1]; + keywords[0] = keyword; + } + } + try { + return analyzer.getOWLClasses(null, keywords, null, false); + }catch(Exception e){ + System.err.println(e); + return null; + } + } + + public Path[] getPaths(String startClass, String endClass, boolean countLink){ + if ( analyzer == null ){ + System.err.println("ERROR. SPARQL endpoint is not decided."); + } + OWLClassGraph graph = new OWLClassGraph(startClass, endClass); + return graph.getPaths(analyzer, countLink); + } + + private void setSPARQLendpoint(String sparqlEndpoint){ + this.sparqlEndpoint = sparqlEndpoint; + setAnalyzer(); + } + + private void setAnalyzer(){ + //analyzer = new EndpointAnalyzer(sparqlEndpoint); //ForTest + + try { + analyzer = factory.create(sparqlEndpoint); + } catch (Exception e) { + System.err.println(e); + } + } +} Index: /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/RDFSchemaAnalyzerFactory.java =================================================================== --- /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/RDFSchemaAnalyzerFactory.java (revision 123) +++ /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/RDFSchemaAnalyzerFactory.java (revision 123) @@ -0,0 +1,55 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.io.File; +import java.util.HashMap; +import java.util.Map; + +import jp.riken.accc.db.rdf.crawler.dataStructure.sparql.JenaModelGenerator; + +public class RDFSchemaAnalyzerFactory { + + private Map acquiredRDFFiles = null; + private static final String FILENAME = "C:\\cdata"; + + public RDFSchemaAnalyzerFactory(String fileName){ + try{ + setAcqiredRDFFiles(new File(fileName)); + }catch(Exception e){ + System.err.println(e); + } + } + + public RDFSchemaAnalyzerFactory(){ + try{ + setAcqiredRDFFiles(new File(FILENAME)); + }catch(Exception e){ + System.err.println(e); + } + } + + private void setAcqiredRDFFiles(String dirFile) throws Exception{ + setAcqiredRDFFiles(new File(dirFile)); + } + + private void setAcqiredRDFFiles(File data) throws Exception{ + StructureCrawler sc = new StructureCrawler(data); + acquiredRDFFiles = sc.getAcquiredStructureFiles(); + } + + public String[] getEndpointURIList(){ + if( acquiredRDFFiles == null ){ + return new String[0]; + }else{ + return acquiredRDFFiles.keySet().toArray(new String[0]); + } + } + + public RDFSchemaAnalyzer create(String uri) throws Exception{ + if( acquiredRDFFiles == null || !acquiredRDFFiles.containsKey(uri)){ + return new EndpointAnalyzer(uri); + }else{ + JenaModelGenerator jmGene = new JenaModelGenerator(acquiredRDFFiles.get(uri)); + return new AcquiredStructureAnalyzer(jmGene.getEndpointURI(), jmGene.getGraphURIs(), jmGene.getModel()); + } + } +} Index: /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/Path.java =================================================================== --- /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/Path.java (revision 123) +++ /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/OWL/Path.java (revision 123) @@ -0,0 +1,114 @@ +package org.biohackathon.SPARQLBuilder.OWL; + +import java.util.List; + +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +/** + * 襍ｷ轤ｹ縺ｨ縺ｪ繧九Μ繧ｽ繝ｼ繧ｹ縺九ｉ騾先ｬ｡逧�↓隍�焚繝ｪ繝ｳ繧ｯ縺ｧ邨らせ繝ｪ繧ｽ繝ｼ繧ｹ縺ｾ縺ｧ謗･邯壹＆繧後ｋ荳縺､縺ｮ繝代せ繧定ｨ倩ｿｰ縺吶ｋ + * + * @author Yamaguchi + * @since 28.01.2014 + * @version 29.01.2014 + */ +public class Path { + + /** + * 繝代せ縺ｮ襍ｷ轤ｹ縺ｨ縺ｪ繧九け繝ｩ繧ｹ縺ｮURI + */ + private String startClass; + private int width; + + /** + * 繝代せ縺ｮ襍ｷ轤ｹ縺九ｉ邨らせ縺ｫ蜷代°縺｣縺ｦ騾先ｬ｡逧�↓縺､縺ｪ縺後ｋ繧ｯ繝ｩ繧ｹ髢薙Μ繝ｳ繧ｯ縺ｮ繝ｪ繧ｹ繝� + */ + private List classLinks; + + public JSONObject toJSON() { + JSONObject obj = new JSONObject(); + try { + obj.put("startClassURI", startClass); + obj.put("width", width); + if (classLinks != null && classLinks.size() != 0) { + JSONArray array = new JSONArray(); + for (int i = 0; i < classLinks.size(); i++) { + array.put(classLinks.get(i).toJSON()); + } + obj.put("classLinks", array); + } + } catch (JSONException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + System.out.println(e.toString()); + } + return obj; + } + + public String toJSONString(){ + return toJSON().toString(); + } + + public String toJSONString2(){ + String json_str=""; + json_str+="{\"startClassURI\":\""+ startClass+"\","; + //json_str+="\"width\":"+width+","; + + if (classLinks != null && classLinks.size() != 0) { + json_str+="\"classLinks\":["; + + JSONObject[] classLinkObjs = new JSONObject[classLinks.size()]; + for (int i = 0; i < classLinks.size(); i++) { + if(i>0){json_str += "," ;} + json_str+= classLinks.get(i).toJSONString2(); + } + json_str+="]"; + } + json_str+="}"; + + return json_str; + } + + + public String getStartClass() { + return startClass; + } + + /* + * public String[] getProperties(){ return properties; } + * + * public String[] getObjectClasses(){ return objectClasses; } + * + * public Direction[] getDirections(){ return directions; } + */ + public List getClassLinks() { + return classLinks; + } + + public int getWidth() { + return width; + } + + public Path() { + } + + public Path(String startClass, List classLinks, int width) { + this.startClass = startClass; + this.classLinks = classLinks; + this.width = width; + } + + public void setStartClass(String startClass) { + this.startClass = startClass; + } + + public void setClassLinks(List classLinks) { + this.classLinks = classLinks; + } + + public void setWidth(int width) { + this.width = width; + } + +} Index: /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/PLServlet.java =================================================================== --- /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/PLServlet.java (revision 123) +++ /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/PLServlet.java (revision 123) @@ -0,0 +1,111 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ + +package org.biohackathon.SPARQLBuilder.www; + +import java.io.IOException; +import java.io.PrintWriter; +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import org.biohackathon.SPARQLBuilder.OWL.*; + +/** + * + * @author atsuko + */ +@WebServlet(name = "PLServlet", urlPatterns = {"/plist"}) +public class PLServlet extends HttpServlet { + + private static final String FILENAME = "cdata/"; + + /** + * Processes requests for both HTTP GET and POST + * methods. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + protected void processRequest(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + response.setContentType("text/html;charset=UTF-8"); + try (PrintWriter out = response.getWriter()) { + /* TODO output your page here. You may use following sample code. */ + out.println(""); + out.println(""); + out.println(""); + out.println("Servlet PLServlet"); + out.println(""); + out.println(""); + out.println("Servlet PLServlet at " + request.getContextPath() + ""); + out.println(""); + out.println(""); + } + } + + // + /** + * Handles the HTTP GET method. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + @Override + protected void doGet(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + //processRequest(request, response); + response.setContentType("application/json;charset=UTF-8"); + PrintWriter out = response.getWriter(); + String ep = request.getParameter("ep"); + String st = request.getParameter("startclass"); + String en = request.getParameter("endclass"); + + QueryPathGenerator qpg = new QueryPathGenerator(ep, FILENAME); + Path[] paths = qpg.getPaths(st, en, true); + String jsonstr = "{\"paths\":["; + for(int i = 0; i< paths.length; i++){ + if (i > 0 ){ + jsonstr += ","; + } + jsonstr += paths[i].toJSONString2(); + } + jsonstr += "]}"; + System.out.println("JSON:"); + System.out.println(jsonstr); + out.print(jsonstr); + } + + /** + * Handles the HTTP POST method. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + @Override + protected void doPost(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + processRequest(request, response); + } + + /** + * Returns a short description of the servlet. + * + * @return a String containing servlet description + */ + @Override + public String getServletInfo() { + return "Short description"; + }// + +} Index: /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/CLServlet.java =================================================================== --- /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/CLServlet.java (revision 123) +++ /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/CLServlet.java (revision 123) @@ -0,0 +1,106 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ + +package org.biohackathon.SPARQLBuilder.www; + +import java.io.IOException; +import java.io.PrintWriter; +import java.math.BigDecimal; +import javax.json.*; +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import org.biohackathon.SPARQLBuilder.OWL.*; + +/** + * + * @author atsuko + */ +@WebServlet(name = "CLServlet", urlPatterns = {"/clist"}) +public class CLServlet extends HttpServlet { + + private static final String FILENAME = "cdata/"; + + /** + * Processes requests for both HTTP GET and POST + * methods. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + protected void processRequest(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + response.setContentType("text/html;charset=UTF-8"); + try (PrintWriter out = response.getWriter()) { + /* TODO output your page here. You may use following sample code. */ + out.println(""); + out.println(""); + out.println(""); + out.println("Servlet CLServlet"); + out.println(""); + out.println(""); + out.println("Servlet CLServlet at " + request.getContextPath() + ""); + out.println(""); + out.println(""); + } + } + + // + /** + * Handles the HTTP GET method. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + @Override + protected void doGet(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + //processRequest(request, response); + response.setContentType("application/json;charset=UTF-8"); + PrintWriter out = response.getWriter(); + String ep = request.getParameter("ep"); + QueryPathGenerator qpg = new QueryPathGenerator(ep, FILENAME); + SClass[] classes = qpg.getClasses(null); + JsonBuilderFactory jbfactory = Json.createBuilderFactory(null); + JsonArrayBuilder jab = jbfactory.createArrayBuilder(); + for (int i = 0 ; i < classes.length; i++ ){ + jab.add(classes[i].getClassURI()); + } + JsonArray ja = jab.build(); + out.print(ja); + } + + /** + * Handles the HTTP POST method. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + @Override + protected void doPost(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + processRequest(request, response); + } + + /** + * Returns a short description of the servlet. + * + * @return a String containing servlet description + */ + @Override + public String getServletInfo() { + return "Short description"; + }// + +} Index: /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/EPServlet.java =================================================================== --- /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/EPServlet.java (revision 123) +++ /SPARQLBuilderWWW/src/java/org/biohackathon/SPARQLBuilder/www/EPServlet.java (revision 123) @@ -0,0 +1,110 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ + +package org.biohackathon.SPARQLBuilder.www; + +import java.io.IOException; +import java.io.PrintWriter; +import javax.servlet.ServletException; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import org.biohackathon.SPARQLBuilder.OWL.*; +import javax.json.*; + +import java.io.*; + +/** + * + * @author atsuko + */ +@WebServlet(name = "EPServlet", urlPatterns = {"/eplist"}) +public class EPServlet extends HttpServlet { + + private RDFSchemaAnalyzerFactory factory = null; + private static final String FILENAME = "cdata/"; + + /** + * Processes requests for both HTTP GET and POST + * methods. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + protected void processRequest(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + response.setContentType("text/html;charset=UTF-8"); + try (PrintWriter out = response.getWriter()) { + /* TODO output your page here. You may use following sample code. */ + out.println(""); + out.println(""); + out.println(""); + out.println("Servlet EPServlet"); + out.println(""); + out.println(""); + out.println("Servlet EPServlet at " + request.getContextPath() + ""); + out.println(""); + out.println(""); + } + } + + // + /** + * Handles the HTTP GET method. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + @Override + protected void doGet(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + //processRequest(request, response); + + response.setContentType("application/json;charset=UTF-8"); + PrintWriter out = response.getWriter(); + if ( factory == null ){ + factory = new RDFSchemaAnalyzerFactory(FILENAME); + } + String[] elist = factory.getEndpointURIList(); + JsonBuilderFactory jbfactory = Json.createBuilderFactory(null); + JsonArrayBuilder jab = jbfactory.createArrayBuilder(); + for (int i = 0; i < elist.length; i++ ){ + jab.add(elist[i]); + } + JsonArray ja = jab.build(); + out.print(ja); + } + + /** + * Handles the HTTP POST method. + * + * @param request servlet request + * @param response servlet response + * @throws ServletException if a servlet-specific error occurs + * @throws IOException if an I/O error occurs + */ + @Override + protected void doPost(HttpServletRequest request, HttpServletResponse response) + throws ServletException, IOException { + processRequest(request, response); + } + + /** + * Returns a short description of the servlet. + * + * @return a String containing servlet description + */ + @Override + public String getServletInfo() { + return "Short description"; + }// + +} Index: /SPARQLBuilderWWW/src/conf/MANIFEST.MF =================================================================== --- /SPARQLBuilderWWW/src/conf/MANIFEST.MF (revision 123) +++ /SPARQLBuilderWWW/src/conf/MANIFEST.MF (revision 123) @@ -0,0 +1,2 @@ +Manifest-Version: 1.0 + Index: /SPARQLBuilderWWW/cdata/chemblF.ttl =================================================================== --- /SPARQLBuilderWWW/cdata/chemblF.ttl (revision 123) +++ /SPARQLBuilderWWW/cdata/chemblF.ttl (revision 123) @@ -0,0 +1,14234 @@ +@base . +<> a ; + + . + +[ a ; + false ; + ; + "181458"^^ ; + + "11592790"^^ ; + "11592790"^^ ; + ; + ; + false +] . + +[ a ; + false ; + ; + "2"^^ ; + + "6"^^ ; + "6"^^ ; + ; + ; + false +] . + +[ a ; + "2"^^ ; + + "3"^^ ; + + "1"^^ ; + "3"^^ ; + +] . + +[ a ; + "4"^^ ; + + "0"^^ ; + + "3"^^ ; + "0"^^ ; + +] . + + + a ; + + "PharmGKB Cross Reference"^^ ; + "1000"^^ . + +[ a ; + false ; + ; + "58"^^ ; + + "58"^^ ; + "58"^^ ; + ; + ; + false +] . + + + + "has attribute"^^ . + + + + ; + + "ChEMBL Activity Entity Published Type"^^ ; + + . + +[ a ; +
+ * 繧ｯ繧ｨ繝ｪ繝薙Ν繝繝ｼ縺ｮ譛ｬ逡ｪ繝励Ο繧ｰ繝ｩ繝縺ｧ縺ｯ縺薙�繝｡繧ｽ繝�ラ縺ｯ菴ｿ逕ｨ縺励↑縺� + *
+ * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧ｯ繝ｩ繧ｹ��dfs:Class�峨ｒ縺吶∋縺ｦ霑斐☆ + *
+ * 謖�ｮ壹＆繧後◆graphURIs縺ｮ荳ｭ縺九ｉ縲√く繝ｼ繝ｯ繝ｼ繝峨↓繝偵ャ繝医☆繧九Λ繝吶Ν繧呈戟縺､繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ繧偵☆縺ｹ縺ｦ霑斐☆ + * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + *
+ * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + * + *
+ * 縺薙％縺ｧ繧､繝ｳ繧ｹ繧ｿ繝ｳ繧ｹ縺ｨ縺ｯ縲〉df:type縺ｮ荳ｻ隱槭→縺励※險倩ｿｰ縺輔ｌ縺ｦ縺�ｋ繧ゅ�繧偵＞縺� + * 蜃ｦ逅�ｯｾ雎｡繝��繧ｿ繧暖raphURIs縺ｧ謖�ｮ壹☆繧九％縺ｨ縺後〒縺阪ｋ + *
GET
POST