Traversing the Graph
The traversal that was evaluated on each database started from some root vertex and emanated n-steps out. There was no sorting, no distinct-ing, etc. The only two variables for the experiments are the length of the traversal and the root vertex to start the traversal from. In MySQL, the following 5 queries denote traversals of length 1 through 5. Note that the "?" is a variable parameter of the query that denotes the root vertex.
SELECT a.inV FROM graph as a WHERE a.outV=?
SELECT b.inV FROM graph as a, graph as b WHERE a.inV=b.outV AND a.outV=?
SELECT c.inV FROM graph as a, graph as b, graph as c WHERE a.inV=b.outV AND b.inV=c.outV AND a.outV=?
SELECT d.inV FROM graph as a, graph as b, graph as c, graph as d WHERE a.inV=b.outV AND b.inV=c.outV AND c.inV=d.outV AND a.outV=?
SELECT e.inV FROM graph as a, graph as b, graph as c, graph as d, graph as e WHERE a.inV=b.outV AND b.inV=c.outV AND c.inV=d.outV AND d.inV=e.outV AND a.outV=?
For Neo4j, the Blueprints Pipes framework was used. A pipe of length n was constructed using the following static method.
public static Pipeline createPipeline(final Integer steps) {
final ArrayList<Pipe> pipes = new ArrayList<Pipe>();
for (int i = 0; i < steps; i++) {
Pipe pipe1 = new VertexEdgePipe(VertexEdgePipe.Step.OUT_EDGES);
Pipe pipe2 = new EdgeVertexPipe(EdgeVertexPipe.Step.IN_VERTEX);
pipes.add(pipe1);
pipes.add(pipe2);
}
return new Pipeline(pipes);
}
For both MySQL and Neo4j, the results of the query (SQL and Pipes) were iterated through. Thus, all results were retrieved for each query. In MySQL, this was done as follows.
while (resultSet.next()) {
resultSet.getInt(finalColumn);
}
In Neo4j, this is done as follows.
while (pipeline.hasNext()) {
pipeline.next();
}
Erwin Karbasi on 13 May 10"Example - the MATRIX The Graph As mentioned before, Social Networks represent just a tiny fraction of the applications of graph databases, but they are easy to understand for this example. To demonstrate the basic functionality of Neo4j, below is a small graph from the Matrix movie, visualized with the Eclipse RCP based Neoclipse for Neo4j: The graph is connected to a known reference node (id=0) for convenience in order to find the way into the network from a known starting point. This is not necessary, but has proven very usable in practice. The Java implementation looks something like this: Create a new graph database in folder "target/neo" EmbeddedGraphDatabase graphdb = new EmbeddedGraphDatabase("target/neo"); Relationship types can be created on-the-fly: RelationshipType KNOWS = DynamicRelationshipType.withName("KNOWS"); or via typesafe Java Enum: enum Relationships implements RelationshipType { KNOWS, INLOVE, HAS_CODED, MATRIX } Now, create two nodes and attach a "name" property to each of them. Then, connect these nodes witha KNOWS relationship: Node neo = graphdb.createNode(); node.setProperty("name", "Neo"); Node morpheus = graphdb.createNode(); morpheus.setProperty("name", "Morpheus"); neo.createRelationshipTo(morpheus, KNOWS); Any operation modifying the graph or needing isolation levels for data is wrapped in a transaction, so rollback and recovery work out of the box: Transaction tx = graphdb.beginTx(); try { Node neo = graphdb.createNode(); ... tx.success(); } catch (Exception e) { tx.failure(); } finally { tx.finish(); } The full code to create the Matrix graph the looks something like this: graphdb = new EmbeddedGraphDatabase("target/neo4j"); index = new LuceneIndexService(graphdb); Transaction tx = graphdb.beginTx(); try { Node root = graphdb.getReferenceNode(); // we connect Neo with the root node, to gain an entry point to the graph // not neccessary but practical. neo = createAndConnectNode("Neo", root, MATRIX); Node mo