Topic: Systems development

Neo4j Performance Revisited and Appreciated

My previous Neo4j performance micro-benchmark left a disturbing hole: There was no explanation why Neo4j didn’t cope well with big transactions.

A closer study uncovered the pretty obvious reason. It also turned out to be the key to zippier Neo4j performance.
Continue »

Low Level File Information For Java

This post is good news for some Java programmers. Once in a while you wish you knew a bit more about the files you access from Java. The class offers only a bare minimum of visibility.

If you are wrestling with this problem, and if you are on a Linux/Unix platform, download the filestat package from this website and get going. This post introduces the package briefly.
Continue »

The Schema-Less Database: Freedom or Bondage?

Some of the new strain of NoSQL databases are schema-less. They also claim this is a feature that brings flexibility. If the schema is such a roadblock, why was it invented in the first place?
Continue »

Why NoSQL Won’t Replace Relational Databases Anytime Soon

These days there is a lot of buzz about NoSQL databases. We hear that new databases are about to replace relational ones because the relational data model is so old.

I’m sure this won’t happen anytime soon. On the other hand, I don’t believe NoSQL databases will go away either. My prediction is that new NoSQL databases will keep popping up. Each one will fill a specific need for a time, and then fade away. No two NoSQL databases will ever be compatible. Standardization is fundamentally contrary to the reason why NoSQL databases exist.

Hang on and I will show you why.
Continue »

Network versus Relational: Part III

In previous posts (original post, follow up) I ran small database performance tests involving Neo4j (a graph or network database) and Apache Derby (a relational database). Both are Java-based.

How about running the same tests with trusty old PostgreSQL? Neo4j and Apache Derby were both embedded in the test application. There was no database server, although Derby may be run in client-server mode.

PostgreSQL is a fully featured RDBMS firmly founded on the classical client-server architecture. It’s been around for ages. The server is coded in C.

The PostgreSQL logo is a stylized head of an elephant. If you think it’s a symbol of heavy feet you are in for a surprise.
Continue »

Network versus Relational: Part II

In a recent post I ran a simplistic database performance test involving Neo4j (a graph or network database) and Apache Derby (a relational database). Both are Java-based. Relational databases are challenged by deep hierarchies, so the test was exactly that: Build a deep hierarchy and retrieve data from it.

The retrieval test was a surprise because relational Derby seemed to perform better than Neo4j.

Anders Nawroth, Neo Technology, correctly commented that the retrieval test case searches for any file in a hierarchy, i.e. the search is independent of the hierarchy. The relational test program took advantage of this fact while Neo4j traversed the the graph.

In the interest of fairness this post digs somewhat deeper into the retrieval test case. The results are intriguing.
Continue »

Network versus Relational

It’s time for the long awaited Network versus Relational database head-to-head, no-mercy showdown. Network databases is represented by Neo4j 1.0, relational by Apache Derby
Continue »

Neo4j vs. Relational: The Relational Combatant

A previous post promised a head-to-head no-mercy Neo4j vs. relational showdown. It also provided Groovy programs to store and retrieve file system data in a Neo4j graph database. Neo4j was recently released in a 1.0 version (see the Neo4j site).

Now it’s time for the relational combatant to enter the scene: Apache Derby.
We will write another Groovy program to store file system data, this time using a Derby relational database. To make the task more interesting we will try to earn a “nosql” medal by not using SQL.
Continue »

Groovy and Neo4j More Seriously

Neo4j is a graph database, recently released in a 1.0 version (see the Neo4j site). A previous post showed a trivial example of using Neo4j from Groovy.

This post contains an example somewhat closer to real life. It is also the first entry in a Neo vs. relational head-to-head no-mercy showdown.
Continue »

Basic Neo4j through Groovy

Neo4j is a graph database, recently released in a 1.0 version (see the Neo4j site). The main programming interface is Java. A lot of Java stuff looks much groovier when run from Groovy. Why not give Neo4j a try?

This post takes the little “Hello world” program from the Neo4j Getting Started Guide and makes it somewhat groovier. A later post will demonstrate a more complete program.
Continue »