[Neo] Groovy and Neo4J
glaforge at gmail.com
Fri Nov 28 16:11:47 CET 2008
I had an email exchange with Emil this morning about what Groovy could
bring to using Neo4J. I think using a dynamic language with a graph
database can make a lot of sense, as it's easier to work with a "less
strict" language with semi structured data not requiring heavyweight
Emil suggested I reproduce the email on this mailing-list, so I'm
happy to echo my small brainstorming session below.
I haven't used Neo4J so far, so I just based my ideas on the
information I gathered looking at the quick start tutorial, so bare
with me if I'm totally nuts ;-)
First, a small introduction: I'm the project lead of the Groovy
I've stumbled upon your presentation of Neo at QCon, on slideshare,
and saw the mention of Groovy near the end :-)
I've always been interested in triplestores, object databases, and so
on, and thought that the flexibility they offer is something I really
miss in relational databases.
I'd love to use something like JCR, triplestores, or now Neo! for a
pet project I had a while ago.
I wish I had been at QCon this year, I would have loved to attend your
session, but that was not the case.
I haven't downloaded and tried Neo yet, but if I find some time, I'd
be happy to give it a try.
As you were mentioning that Groovy should probably work well with Neo,
yes, I'm pretty certain it does, and I'm sure we could bring some
Groovyisms into the loop to make using Neo even more seamless and
For instance, if I look at your quick start example:
Node firstNode = neo.createNode();
Node secondNode = neo.createNode();
Relationship relationship = firstNode.createRelationshipTo(
secondNode, MyRelationshipTypes.KNOWS );
firstNode.setProperty( "message", "Hello, " );
secondNode.setProperty( "message", "world!" );
relationship.setProperty( "message", "brave Neo " );
Groovy handles the setProperty/getProperty methods in a particular
fashion, and without doing anything special, you should be able to
directly use this nicer syntax in Groovy:
firstNode.message = "Hello"
secondNode.message = "world!"
relationship.message = "brave Neo"
It really gives people the impression of working with real objects,
with real properties or methods.
With maps or expandos in Groovy, you can already manipulate
quasi-beans with that syntax, and people may potentially not need to
manipulate Node or Relationship directly, but could use these maps /
expandos instead, and it would only be when storing these in the graph
database that you could "coerce" the type to Node or Relationship.
def firstNode = [:]
firstNode.message = "Hello"
And you could then just call some store() method in your APIs --
although it seems in the tutorial, there's no need to "store", just
creating the nodes and relationships are enough.
Also for relationships, we could imagine using Groovy's native list
syntax for representing such triples (and using static import for
def relationship = [ firstNode, KNOWS, secondNode ]
[KNOWS: [since: someDate],
I was also mentioning coercion, as you can create custom type coercion
in Groovy (kind of a cast, if you wish, but you can transform
something into some other type):
[name: "Neo"] as Node
[ firstNode, KNOWS, secondNode ] as Relationship
Or simply at declaration time:
Node neo = [name: "Neo"]
Relationship rel = [ firstNode, KNOWS, secondNode ]
Anyway... enough brainstorming for now, but a graph database like Neo
and a dynamic language like Groovy, and you can really really have
Congratulations for a great graph database project!
Keep up the good work.
Groovy Project Manager
Head of Groovy Development at SpringSource
More information about the User