/*
* Copyright 2014 NUST. All rights reserved.
* Use is subject to license terms.
*/
package com.neo4j.jena.graph;
import org.apache.http.MethodNotSupportedException;
import org.neo4j.cypher.javacompat.ExecutionEngine;
import org.neo4j.cypher.javacompat.ExecutionResult;
import org.neo4j.graphdb.GraphDatabaseService;
import org.neo4j.graphdb.Relationship;
import org.neo4j.graphdb.Transaction;
import org.neo4j.graphdb.factory.GraphDatabaseFactory;
import org.neo4j.tooling.GlobalGraphOperations;
import com.hp.hpl.jena.graph.BulkUpdateHandler;
import com.hp.hpl.jena.graph.Capabilities;
import com.hp.hpl.jena.graph.Graph;
import com.hp.hpl.jena.graph.GraphEventManager;
import com.hp.hpl.jena.graph.GraphStatisticsHandler;
import com.hp.hpl.jena.graph.Node;
import com.hp.hpl.jena.graph.TransactionHandler;
import com.hp.hpl.jena.graph.Triple;
import com.hp.hpl.jena.graph.TripleMatch;
import com.hp.hpl.jena.graph.impl.SimpleEventManager;
import com.hp.hpl.jena.shared.AddDeniedException;
import com.hp.hpl.jena.shared.DeleteDeniedException;
import com.hp.hpl.jena.shared.PrefixMapping;
import com.hp.hpl.jena.util.iterator.ExtendedIterator;
import com.hp.hpl.jena.vocabulary.DC_11;
import com.hp.hpl.jena.vocabulary.OWL;
import com.hp.hpl.jena.vocabulary.RDF;
import com.hp.hpl.jena.vocabulary.RDFS;
import com.hp.hpl.jena.vocabulary.XSD;
/**
* Jena graph wrapper for Neo4J graph database service.
*
* @author Khalid Latif, Mahek Hanfi (2014-02-14)
*/
public class NeoGraph implements Graph {
public static final String PROPERTY_DATATYPE = "type";
public static final String PROPERTY_KIND = "kind";
public static final String PROPERTY_LANGUAGE = "lang";
public static final String PROPERTY_NG = "ng";
public static final String PROPERTY_URI = "uri";
public static final String PROPERTY_VALUE = "value";
public static final String LABEL_BNODE = "bnode";
public static final String LABEL_LITERAL = "literal";
public static final String LABEL_URI = "uri";
/** Neo4J graph database */
final GraphDatabaseService graphdb;
/** Graph event manager */
private GraphEventManager eventManager;
/** Factory of unique nodes */
final UniqueNodeFactory nodeFactory;
/** Factory for unique relationships */
final UniqueRelationshipFactory relationshipFactory;
/** Prefix mappings */
PrefixMapping mapping;
/**
* Loads Neo4J graph from given directory.
*
* @see #NeoGraphBase(GraphDatabaseService)
*/
public NeoGraph(final String directory) {
this(new GraphDatabaseFactory().newEmbeddedDatabase(directory));
}
/**
* Initializes this graph.
*/
public NeoGraph(final GraphDatabaseService graphdb) {
this.graphdb = graphdb;
try(Transaction tx = graphdb.beginTx()) {
nodeFactory = new UniqueNodeFactory(graphdb, this);
relationshipFactory = new UniqueRelationshipFactory(graphdb, this);
}
}
/**
* Add triple in the graph.
* First convert Jena triple to Neo4j node and relationship and then add it in the neo4j graph
*/
@Override
public void add(Triple triple) throws AddDeniedException {
try (Transaction tx = graphdb.beginTx()) {
// Get or create a node for subject
org.neo4j.graphdb.Node subject = nodeFactory.getOrCreate(triple.getSubject());
// Get or create a node for object
org.neo4j.graphdb.Node object = nodeFactory.getOrCreate(triple.getObject());
// Don't add triple if relationship already exists
relationshipFactory.getOrCreate(subject, triple.getPredicate().getURI(), object);
tx.success();
}
}
@Override
public void clear() {
throw new RuntimeException(new MethodNotSupportedException("clear"));
}
/**
* Shutdown the graph.
*/
@Override
public void close() {
graphdb.shutdown();
}
/**
* Checks if the given triple exist in the graph.
*/
@Override
public boolean contains(Triple triple) {
return contains(triple.getSubject(), triple.getPredicate(), triple.getObject());
}
/**
* Checks if the given triple exist in the graph.
*/
@Override
public boolean contains(Node subject, Node predicate, Node object) {
try(Transaction tx = graphdb.beginTx()) {
// Check subject
org.neo4j.graphdb.Node sub= nodeFactory.get(subject);
if(sub!=null) {
// Check object
org.neo4j.graphdb.Node obj = nodeFactory.get(object);
if(obj!=null) {
// Check relationship
Relationship relation = relationshipFactory.get(sub, predicate.getURI(), obj);
if(relation!=null) {
tx.success();
return true;
}
}
}
}
return false;
}
/**
* Delete the given triple from the graph.
*/
@Override
public void delete(Triple triple) throws DeleteDeniedException {
Transaction tx=graphdb.beginTx();
org.neo4j.graphdb.Node subject = nodeFactory.get(triple.getSubject());
System.out.println("Subject node:" + subject.getProperty("uri"));
if(subject!=null) {
org.neo4j.graphdb.Node object = nodeFactory.get(triple.getObject());
System.out.println("Object node:" + object.getProperty("uri"));
if(object!=null) {
Relationship relation = relationshipFactory.get(subject, triple.getPredicate().getURI(), object);
System.out.println("Relationship:" +relation.getProperty("uri"));
if(!subject.hasRelationship())
subject.delete();
if(triple.getObject().isLiteral())
object.delete();
else if(!object.hasRelationship())
object.delete();
}
tx.success();
}
}
@Override
public boolean dependsOn(Graph arg0) {
throw new RuntimeException(new MethodNotSupportedException("dependsOn"));
}
/**
* Find the given triple(s) from the graph.
*/
@Override
public ExtendedIterator<Triple> find(TripleMatch triple) {
return find(triple.getMatchSubject(),triple.getMatchPredicate(), triple.getMatchObject());
}
/**
* Find the given triple(s) from the graph.
*/
@Override
public ExtendedIterator<Triple> find(Node subject, Node predicate, Node object) {
//System.out.println("NeoGraph#find");
try(Transaction tx = graphdb.beginTx()) {
StringBuffer query = new StringBuffer("MATCH triple=");
query.append("(subject");
if(subject.equals(Node.ANY)) {
query.append(":"+ LABEL_URI);
//System.out.println("NeoGraph#find#Any:"+subject);
} else if(subject.isURI()){
query.append(":"+LABEL_URI+" {uri:'");
query.append(subject.getURI());
query.append("'}");
//System.out.println("NeoGraph#find#URI:"+subject+subject.getURI());
} else {
query.append(":" + LABEL_BNODE);
//System.out.println("NeoGraph#find#"+subject);
}
query.append(")-[predicate]->(object");
//query.append("]->(object");
if(object.equals(Node.ANY)) {
//query.append(" ");
} else if(object.isURI()){
query.append(":"+LABEL_URI+" {uri:'");
query.append(object.getURI());
query.append("'}");
} else {
query.append(":"+LABEL_LITERAL+" {value:'");
query.append(object.getLiteralValue());
query.append("'}");
}
query.append(")");
//System.out.println("Predicate in query: " +getPrefixMapping().shortForm(predicate.getURI()));
if(predicate.isURI()) {
query.append("WHERE type(predicate)='");
query.append(getPrefixMapping().shortForm(predicate.getURI()));
query.append("'");
}
query.append("\nRETURN subject, type(predicate), object");
//System.out.println(query.toString());
ExecutionEngine engine = new ExecutionEngine(graphdb);
ExecutionResult results = engine.execute(query.toString());
//System.out.println(results.dumpToString());
//System.out.println("NeoGraph#find#"+predicate);
//System.out.println("NeoGraph#find#"+object);
//System.out.println("NeoGraph#find#DONE");
return new ExecutionResultIterator(results, graphdb);
}
}
@Override
public BulkUpdateHandler getBulkUpdateHandler() {
throw new RuntimeException(new MethodNotSupportedException("getBulUpdate"));
}
@Override
public Capabilities getCapabilities() {
return NeoCapabilities.DEFAULT;
}
@Override
public GraphEventManager getEventManager() {
if(eventManager==null)
eventManager = new SimpleEventManager(this);
return eventManager;
}
@Override
public PrefixMapping getPrefixMapping() {
if(mapping==null) {
PrefixMapping standard = PrefixMapping.Factory.create()
.setNsPrefix( "rdfs", RDFS.getURI() )
.setNsPrefix( "rdf", RDF.getURI() )
.setNsPrefix( "dc", DC_11.getURI() )
.setNsPrefix( "owl", OWL.getURI() )
.setNsPrefix( "xsd", XSD.getURI() );
mapping = new NeoPrefixMapping(null, standard);
}
return mapping;
}
@Override
public GraphStatisticsHandler getStatisticsHandler() {
throw new RuntimeException(new MethodNotSupportedException("getStatsHandler"));
}
@Override
public TransactionHandler getTransactionHandler() {
throw new RuntimeException(new MethodNotSupportedException("getTransactionHandler"));
}
/**
* Checks if the graph is closed or not.
*/
@Override
public boolean isClosed() {
if(graphdb.isAvailable(0))
return true;
else
return false;
}
/**
* Checks if the grpah is empty or not
*/
@Override
public boolean isEmpty() {
Transaction tx = graphdb.beginTx();
Iterable<org.neo4j.graphdb.Node> nodes= GlobalGraphOperations.at(graphdb).getAllNodes();
boolean empty = nodes.iterator().hasNext();
tx.success();
return !empty;
}
@Override
public boolean isIsomorphicWith(Graph arg0) {
throw new RuntimeException(new MethodNotSupportedException("isIsomorphic"));
}
@Override
public void remove(Node arg0, Node arg1, Node arg2) {
throw new RuntimeException(new MethodNotSupportedException("remove"));
}
@Override
public int size() {
throw new RuntimeException(new MethodNotSupportedException("size"));
}
public void startBulkLoad() {
nodeFactory.startBulkLoad();
}
public void stopBulkLoad() {
nodeFactory.stopBulkLoad();
}
}
