Neo4j getting a JDBC driver before MongoDB is a surprise^[1]. Rickard Öberg:

When it comes to NOSQL databases, one of the key advantages is that they allow you to structure your data in a way that better resembles your domain, and also allows you to use query languages where you can express things that are either really awkward or slow with SQL. However, one of the advantages that relational databases have is that they can be accessed from lots of tools using JDBC, as a standard API. So what would happen if a NOSQL database, like Neo4j, also had a JDBC driver? I decided to find out!

If this catches up, the next step is adding a non-HTTP protocol to Neo4j server.

Original title and link: Neo4j Gets Experimental JDBC Driver (NoSQL database©myNoSQL)

via: http://rickardoberg.wordpress.com/2011/12/19/creating-a-jdbc-driver-for-neo4j/

The relationship between a person and a project has an associated role. This relationship is also the basis for the list of collaborators: two people are collaborators if there’s at least one project of which they’re both members.

Solve this with a relational database.

Original title and link: Neo4j Domain Modeling With Spring Data (NoSQL database©myNoSQL)

via: http://skydingo.com/blog/?p=64

Willie Wheeler describing the challenges of a configuration management database:

My experience has been that the data persistence layer is the one that’s most challenging to change. Besides the actual schema changes, we have to write data migration scripts, we have to make corresponding changes to our integration test data scripts, we have to make sure Hibernate’s eager- and lazy-loading are doing the right things, sometimes we have to change the domain object APIs and associated Hibernate queries, etc. Certainly doable, but there’s generally a good deal of planning, discussion and testing involved.

Then the benefits of using Neo4j and Spring Data for building it:

• There are many entities and relationships.
• We need schema agility to experiment with different CMDB approaches.
• We need schema agility to accommodate continuing innovations in infrastructure.
• We need schema flexibility to accommodate the needs of different organizations.
• But we still need structure.
• A schemaless backend makes zero-downtime deployments easier.
• We want to support intuitive querying.

Solving the same problem, Puppet is using CouchDB for configuration management.

Original title and link: Neo4j and Spring Data for Configuration Management Database (NoSQL database©myNoSQL)

via: http://skydingo.com/blog/?p=28

Remember how useful it was to see how MapReduce translates to SQL? In a similar vein, Andrés Taylor dives into Cypher, the Neo4j querying language introduced in Neo4j 1.4, explaining it from the perspective of an SQL person:

Unlike SQL which operates on sets, Cypher predominantly works on subgraphs. The relational equivalent is the current set of tuples being evaluated during a SELECT query.

Original title and link: Neo4j Querying for SQL People (NoSQL database©myNoSQL)

via: http://systay.github.com/blog/2011/11/06/cypher---a-view-from-a-recovering-sql-dba/

Jasper Pei Lee provides an overview of the following graph databases from the perspective of the Java developer: Neo4j, InfiniteGraph, DEX, InfoGrid, HyperGraphDB, Trinity, AllegroGraph:

His review is similar to the Quick Review of Existing Graph Databases, but stays focused on using these graph databases from a Java environment, this making it less generic than the NoSQL Graph Database Matrix.

The only part that I didn’t understand is the closing:

High-performance and distributed deploy are supposed to be supported by all products.

Without qualifying what high-performance means is difficult to assess if all reviewed products are on par^[1]. And scaling graph databases is far from being a solved problem.

Original title and link: A Survey of Graph Databases for the Java Programmers (NoSQL database©myNoSQL)

via: http://jasperpeilee.wordpress.com/2011/11/25/a-survey-on-graph-databases/

Andres Almiray:

The following list enumerates all NoSQL options currently supported by Griffon via plugins:

• BerkeleyDB
• CouchDB
• Memcached
• Riak
• Redis
• Terrastore
• Voldemort
• Neo4j
• Db4o
• Neodatis

The first 7 are Key/Value stores. Neo4j is a Graph based database. The last two are object stores. All of them support multiple datasources, data bootstrap and a Java friendly API similar to the one shown earlier.

Griffon is a Groovy-based framework for developing desktop applications. While the coolness factor of Java-based desktop apps is close to zero, having some multi-platform management utilities for these NoSQL databases might be interesting.

Original title and link: Griffon and NoSQL Databases (NoSQL database©myNoSQL)

via: http://www.jroller.com/aalmiray/entry/griffon_to_sql_or_nosql

Spring Data continues its march to “be all do all”:

During the last months of Neo4j development the improved querying (Cypher, Gremlin) support was one of the important aspects. So we strove to support it on all levels. Now, it is possible to execute Cypher queries from Spring Data Graph Repositories, from the Neo4j-Template but also as part of dynamic field annotations and via the introduced entity methods. The same goes for Gremlin scripts.

Original title and link: Spring Data Graph 1.1.0 Released (NoSQL database©myNoSQL)

via: http://blog.neo4j.org/2011/08/spring-data-graph-1.html

[…] we’ve built up a Doctor Who data model that shows how Neo4j can be used to address several different data and domain concerns. For example, part of the dataset includes timeline data, comprising seasons, stories and episodes; elsewhere we’ve social network-like data, with characters connected to one another through being companions, allies or enemies of the Doctor. It’s a messy and densely-connected dataset – much like the data you might find in a real-world enterprise. Some of it is of high quality, some of it is lacking in detail. And for every seeming invariant in the domain, there’s an awkward exception – again, much like the real world.

Ian Robinson’s post will walk you through the details of structuring and querying the data with Neo4j. The complete source code is available on GitHub.

Original title and link: Neo4j Tutorial: The Power of the Daleks (NoSQL database©myNoSQL)

via: http://iansrobinson.com/2011/07/11/the-power-of-the-daleks-and-neo4j/