Topic: Database views


I’m nearing completion of my first serious project based on sqlite. It’s been there for ages, but it’s always been a niche database. Until now I haven’t found an occasion to use it. Now, having had a close encounter, I’m impressed. Continue »

NoSQL: Don’t Take the Drug Unless You Have the Symptoms

NoSQL databases are hot, and rightly so. Many of them aspire to solve some of the trickiest database problems of all, problems that have been nagging database research for decades: scaling up and scaling out.

In some trade press and other places the NoSQL discussion has to be simplified. Sometimes a casual reader may get the impression that NoSQL just makes relational databases old-fashioned. This is very far from the truth. NoSQL is there to cure specific ailments. If you don’t suffer from any of those specific symptoms, the side effects from taking NoSQL medication may cause more pain than relief. I’ll explain why and let’s see if you agree.
Continue »

Neo4j Performance: Another Notch

In a number of posts I devised various database micro-benchmarks. The idea was to set the stage for an epic battle between NoSql and relational. In less grandiose terms I tested Neo4j, an all-Java network database, Apache Derby, an all-Java relational database and PostgreSQL, trusted non-Java relational workhorse with a heritage.

This is a short closing note in the series, commenting on Neo4j performance.
Continue »

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 »

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 »