blueprints

Titan in my opinion is the most promising Big Data graph DB around, due to the fact that it works on top of Cassandra (and HBase). But, there are other very good graph DBs out there too, like OrientDB. What is important in my opinion, is for all of these graph DBs to embrace the Tinkerpop Blueprints graph API (which Titan and OrientDB do). https://github.com/tinkerpop/blueprints/wiki

Gremlin has custom Tree step: https://github.com/tinkerpop/gremlin/wiki/Tree-Pattern You can use Gremlin with any TinkerPop/Blueprints (https://github.com/tinkerpop/blueprints/wiki) enabled graph database (which means almost all graph DBs).

Of course, the flippant answer to this is that our codebases are already databases - the filesystem is our storage engine, commits are our transactions, etc. But is this the optimal way to store information? It would be very interesting to look at code as a graph database (of the https://github.com/tinkerpop/blueprints/wiki family, for instance). In a way, one could see how a functional programming language defines entities and their relationships, and how a function is just a composition of other functions to which it could be linked. But do we want to write a graph operation every time we want to make an edit or add a feature to our code? Perhaps the textual codebases we have are the most easily editable visualization of the underlying "graph."

I'm at the beginning of a research cycle on graph databases Pretty much the same here. I am not an expert on any of these projects yet, but I can share some of what I've found and been researching so far. and am curious to get some suggestions of your favorite open source projects? Depends on exactly what you are looking for. There are graph "databases" and there are graph "processing engines" and there are subtle differences between them. Some of these things gain massive scalability by running on top of Hadoop, others implement Bulk Synchronous Parallel processing, etc. A few interesting choices you could look at include: Apache Giraph - http://giraph.apache.org/ Titan - http://thinkaurelius.github.io/titan/ Faunus - http://thinkaurelius.github.io/faunus/ Apache Hama - http://hama.apache.org/ - not strictly a graph database OR a graph

One tangential direction we want to go with Titan is benchmarking it as a distributed RDF store. With edge indexing now in Titan 0.3.0 and Blueprints Sail (GraphSail), Titan can represent an RDF graph and be queried using SPARQL. https://github.com/tinkerpop/blueprints/wiki/Sail-Ouplementation

No, OrientDB is not an "elaborate hoax" :) -- it's very real and developed by Luca Garulli (https://github.com/lvca). OrientDB is one of the primary Blueprints implementations (https://github.com/tinkerpop/blueprints) so it integrates with the TinkerPop stack as well.

Titan currently does not have "edge indexing" and thus can not implement Blueprints' GraphSail interface [https://github.com/tinkerpop/blueprints/wiki/Sail-Ouplementa...]. If it did implement GraphSail, then SPARQL would be supported via the Sail SPARQL engine.

Also for SPARQL/Sail look for the Sail Ouplementation by tinkerpop which runs on top of Neo4j. (https://github.com/tinkerpop/blueprints/wiki/Sail-Ouplementa...)

That seems strange to me. It's possible to do a really nice job with it, as evidenced by (at least) the Blueprints project: https://github.com/tinkerpop/blueprints/wiki

Davy implemented Datomic as a TinkerPop Blueprints graph (https://github.com/tinkerpop/blueprints/wiki/) so you can query it with Gremlin (https://github.com/tinkerpop/gremlin/wiki) too... "The use of Datoms and Datalog allows you to express simple, yet powerful queries. This article introduces only a fraction of the features offered by Datomic. To get myself better acquainted with the various Datomic gotchas, I implemented the Tinkerpop Blueprints API on top of Datomic. By doing so, you basically get a distributed, temporal graph database, which is, as far as I know, unique within the Graph database ecosystem. The source code of this Blueprints implementation can currently be found on the Datablend public GitHub repository and will soon be merged within the Tinkerpop project."

Even though it's over REST, you can still have "transactional domain objects wrapped around nodes and relationships." Neo4j is working on providing RESTful transactions for the Neo4j REST server (http://www.mail-archive.com/user@lists.neo4j.org/msg08253.ht...), and you can already do this with Rexster. Here's a Bulbs (Python) example of what a domain object looks like wrapped around a node: from bulbs.model import Node, Relationship from bulbs.datatype import Property, Integer, String class Person(Node): element_type = "person" name = Property(String, nullable=False) age = Property(Integer) james = Person(name="James", age=34) julie = Person(name="Julie", age=28) Relationship.create(james,"knows",julie) As I said in another thread, Bulbs connects to Neo4j through the Rexster REST server, and binary b

TinkerGraph is close (https://github.com/tinkerpop/blueprints/wiki/TinkerGraph) -- it used to be an in-memory only graph, but you can now persist it. Also look at GraphML (http://graphml.graphdrawing.org) and the full TinkerPop stack (http://www.tinkerpop.com). Gremlin (https://github.com/tinkerpop/gremlin/wiki) is a graph query lanaguage and one of the main discussions groups for general graph database stuff is the Gremlin Users group (https://groups.google.com/forum/#!forum/gremlin-users) -- ask your question about the portable library in there -- the group was created by Marko, the guy who wrote TinkerGraph. Here's a 10 min screencast on Gremlin: http://www.youtube.com/watch?v=5wpTtEBK4-E Rexster (https://github.com/tinkerpop/rexster/wiki/) is a REST server that has Gremlin built in, and it interfaces with most of the graph databases,