NoSQL Benchmarks NoSQL use cases NoSQL Videos NoSQL Hybrid Solutions NoSQL Presentations Big Data Hadoop MapReduce Pig Hive Flume Oozie Sqoop HDFS ZooKeeper Cascading Cascalog BigTable Cassandra HBase Hypertable Couchbase CouchDB MongoDB OrientDB RavenDB Jackrabbit Terrastore Amazon DynamoDB Redis Riak Project Voldemort Tokyo Cabinet Kyoto Cabinet memcached Amazon SimpleDB Datomic MemcacheDB M/DB GT.M Amazon Dynamo Dynomite Mnesia Yahoo! PNUTS/Sherpa Neo4j InfoGrid Sones GraphDB InfiniteGraph AllegroGraph MarkLogic Clustrix CouchDB Case Studies MongoDB Case Studies NoSQL at Adobe NoSQL at Facebook NoSQL at Twitter



neo4j: All content tagged as neo4j in NoSQL databases and polyglot persistence

Neo4j Gets Experimental JDBC Driver

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.

  1. MongoDB is the NoSQL database with the richest querying model which resembles SQL.  

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


Neo4j Domain Modeling With Spring Data

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.

Domain modeling with Spring Data Neo4j

Solve this with a relational database.

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


Neo4j and Spring Data for Configuration Management Database

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)


NoSQL Screencasts: Neo4j for Ruby and Java People, Plus Data Modeling and Querying

Before the weekend is over, you could spend a bit of time experimenting with Neo4j. If you are a Ruby person then you’ve probably learned from the persistent graph structures with Ruby/Rails thread that Neo4j with JRuby is the way to go. In the first video Peter Neubauer demonstrates the process of building and deploying a Neo4j-enabled application on Heroku:

Persistent Graph Structures With Ruby/Rails

Summarizing this long thread trying to answer the question in the title: Neo4j + JRuby.

Original title and link: Persistent Graph Structures With Ruby/Rails (NoSQL database©myNoSQL)

Neo4j Querying for SQL People

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.

Cypher: Neo4j query language

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


A Survey of Graph Databases for the Java Programmers

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:

Graph Databases for the Java Programmers

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.

  1. AllegroGraph takes pride in breaking records related to the number of stored triples, while others are focused on access speed, or reliability.  

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


Griffon and NoSQL 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)


Graph Databases Market Penetration

Emil Eifrem (Neo4j) in an interview for StartUpBeat answering a question about the competition in the graph databases space (my emphasis):

There’s a lot of movement around alternative databases today and a lot of companies in NOSQL like MongoDB, Couchbase and Cassandra. However, when we’re out in the field and talking to customers, our actual competitors are in-house custom-built solutions.

This answer made me think that:

  1. Neo4j is the by far the graph databases market leader. And I’m not sure there’s a second place (InfiniteGraph maybe?).
  2. graph databases are still either unknown in many environments or perceived as niche solutions.

If I’d be a graph database producer, I’d not worry much about my product rank in the market. But I’d definitely be concerned about the current market size and graph databases market penetration in general.

Original title and link: Graph Databases Market Penetration (NoSQL database©myNoSQL)

Spring Data Graph 1.1.0 Released

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)


Neo4j Tutorial: The Power of the Daleks

[…] 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)