NOSQL har igennem de sidste år, gået sin sejrsgang i alle store virksomheder. Og der er kommet flere teknologier og flere producenter og opensource projekter på gaden… Hele NOSQL økosamfunder er vokset enormt, godt hjulet af verdens bedste referencer, nemlig de mest kendte brands i verden som entydigt lovpriser NOSQL.

NOSQL giver bedre vækst for dig, ifølge verdens største analyse- og konsulenthuse

Dertil kommer f.eks. at flere af verdens mest kendte analyservirksomheder er kommet til den overraskende konklusion at DU SKAL anvende NOSQL teknologi HVIS DU VIL HAVE SUCCESS!… Denne konklusion er sket på basis af virksomheders teknologivalg sammenlignet med tilsvarende konkurrenter, som ikke anvender NOSQL. Konklusionen er, at d skal anvende NOSQL hvis du vil vækste fra 2-40 gange hurtigere end dine konkurrenter.

Hvilken NOSQL database skal man vælge?

De traditionelle SQL databaser er kommet til kort overfor NOSQL. De er for dyre, for langsomme og for usikre, jf. flere af USA’s største analysevirksomheder. SQL producenterne har ellers i de sidste 5 år haft en slags monopol på hvordan vi gemte vore data. Det er slut nu, idet NOSQL er verdens hastigst voksende teknologi og samtidigt den teknologi vi benytte mest til daglig i form af Google, Facebook og specielt Cloud Tjenester. CMS industien er næsten alle igang med implementering af interfaces til NOSQL hvor eller MYSQL har været dominerende.

Problemet har været at selvom SQL er ok til nogle få ting, så er det for langsomt, for dyrt og for usikkert (antallet af sikkerhedshuller).

NOSQL markedet er pt. domineret af Cassandra, Mongodb, Redis, Riak, CouchDB, Membase, Neo4j og HBase. Vi giver her en sammenligning af de teknologier som er motoren i NOSQL databasen og hvilke hovedsprog de er programmeret i samt detaljer om interfaces og generelle holdninger og meninger.

MongoDB

Skrevet i: C++
Fordel: Har nogle brugervenlige egenskaber fra SQL. (Query, index)
Licens: AGPL (Drivers: Apache)
Protokol: Custom, binary (BSON)
Master/slave replikering (auto failover med replikeringssæt)
Sharding indbygget
Forespørgsler er javascript udtryk
Kører arbitrære javascript funktioner på server-siden
Bedre til opdateringer end CouchDB
Bruger hukommelses-mappede filer for datalagring
Performance er bedre end antallet af faciliteter
Journalisering (med –journal) er bedre når den er aktiveret
På 32 bit systemer er der en begrænsning på ~2.5Gb
En tom database fylder indtil 192Mb
GridFS for at gemme BIGDATA og metadata (er faktisk ikke FS)
Har geospatial indexing

Bruges bedst til: hvis der er behov for dynamiske forespørgsler. Hvis du foretrækker at definere indexes, og ikke map/reduce funktioner. Hvis der er behov for god performance på en stor database. Hvis du gerne ville have CouchDB eller CouchBase, men dine data ændrer dig for tit og fylder meget.

For eksempel: hvis du f.eks. kunne klare dig med MySQL eller PostgreSQL, men det at have prædefinerede koloner holder dig tilbage.

Riak (V1.0)

Skrevet i: Erlang & C, og lidt Javascript
Fordel: Fejltolerant
Licens: Apache
Protokol: HTTP/REST or custom binary
Tunable trade-offs for distribution and replication (N, R, W)
Pre- and post-commit hooks in JavaScript or Erlang, for validation and security.
Map/reduce in JavaScript or Erlang
Links & link walking: use it as a graph database
Secondary indices: but only one at once
Large object support (Luwak)
Comes in “open source” and “enterprise” editions
Full-text search, indexing, querying with Riak Search server (beta)
In the process of migrating the storing backend from “Bitcask” to Google’s “LevelDB”
Masterless multi-site replication replication and SNMP monitoring are commercially licensed

Best used: If you want something Cassandra-like (Dynamo-like), but no way you’re gonna deal with the bloat and complexity. If you need very good single-site scalability, availability and fault-tolerance, but you’re ready to pay for multi-site replication.

For example: Point-of-sales data collection. Factory control systems. Places where even seconds of downtime hurt. Could be used as a well-update-able web server.

CouchDB (V1.1.1)

Written in: Erlang
Main point: DB consistency, ease of use
License: Apache
Protocol: HTTP/REST
Bi-directional (!) replication,
continuous or ad-hoc,
with conflict detection,
thus, master-master replication. (!)
MVCC – write operations do not block reads
Previous versions of documents are available
Crash-only (reliable) design
Needs compacting from time to time
Views: embedded map/reduce
Formatting views: lists & shows
Server-side document validation possible
Authentication possible
Real-time updates via _changes (!)
Attachment handling
thus, CouchApps (standalone js apps)
jQuery library included

Best used: For accumulating, occasionally changing data, on which pre-defined queries are to be run. Places where versioning is important.

For example: CRM, CMS systems. Master-master replication is an especially interesting feature, allowing easy multi-site deployments.

Redis (V2.4)

Written in: C/C++
Main point: Blazing fast
License: BSD
Protocol: Telnet-like
Disk-backed in-memory database,
Currently without disk-swap (VM and Diskstore were abandoned)
Master-slave replication
Simple values or hash tables by keys,
but complex operations like ZREVRANGEBYSCORE.
INCR & co (good for rate limiting or statistics)
Has sets (also union/diff/inter)
Has lists (also a queue; blocking pop)
Has hashes (objects of multiple fields)
Sorted sets (high score table, good for range queries)
Redis has transactions (!)
Values can be set to expire (as in a cache)
Pub/Sub lets one implement messaging (!)

Best used: For rapidly changing data with a foreseeable database size (should fit mostly in memory).

For example: Stock prices. Analytics. Real-time data collection. Real-time communication.

HBase (V0.92.0)

Written in: Java
Main point: Billions of rows X millions of columns
License: Apache
Protocol: HTTP/REST (also Thrift)
Modeled after Google’s BigTable
Uses Hadoop’s HDFS as storage
Map/reduce with Hadoop
Query predicate push down via server side scan and get filters
Optimizations for real time queries
A high performance Thrift gateway
HTTP supports XML, Protobuf, and binary
Cascading, hive, and pig source and sink modules
Jruby-based (JIRB) shell
Rolling restart for configuration changes and minor upgrades
Random access performance is like MySQL

Best used: When you use the Hadoop/HDFS stack. When you need random, realtime read/write access to BigTable-like data.

For example: For data that’s similar to a search engine’s data

Neo4j (V1.5M02)

Written in: Java
Main point: Graph database – connected data
License: GPL, some features AGPL/commercial
Protocol: HTTP/REST (or embedding in Java)
Standalone, or embeddable into Java applications
Full ACID conformity (including durable data)
Both nodes and relationships can have metadata
Integrated pattern-matching-based query language (“Cypher”)
Also the “Gremlin” graph traversal language can be used
Indexing of nodes and relationships
Nice self-contained web admin
Advanced path-finding with multiple algorithms
Indexing of keys and relationships
Optimized for reads
Has transactions (in the Java API)
Scriptable in Groovy
Online backup, advanced monitoring and High Availability is AGPL/commercial licensed

Best used: For graph-style, rich or complex, interconnected data. Neo4j is quite different from the others in this sense.

For example: Social relations, public transport links, road maps, network topologies.

Cassandra

Written in: Java
Main point: Best of BigTable and Dynamo
License: Apache
Protocol: Custom, binary (Thrift)
Tunable trade-offs for distribution and replication (N, R, W)
Querying by column, range of keys
BigTable-like features: columns, column families
Has secondary indices
Writes are much faster than reads (!)
Map/reduce possible with Apache Hadoop
I admit being a bit biased against it, because of the bloat and complexity it has partly because of Java (configuration, seeing exceptions, etc)

Best used: When you write more than you read (logging). If every component of the system must be in Java. (“No one gets fired for choosing Apache’s stuff.”)

For example: Banking, financial industry (though not necessarily for financial transactions, but these industries are much bigger than that.) Writes are faster than reads, so one natural niche is real time data analysis.

Membase

Written in: Erlang & C
Main point: Memcache compatible, but with persistence and clustering
License: Apache 2.0
Protocol: memcached plus extensions
Very fast (200k+/sec) access of data by key
Persistence to disk
All nodes are identical (master-master replication)
Provides memcached-style in-memory caching buckets, too
Write de-duplication to reduce IO
Very nice cluster-management web GUI
Software upgrades without taking the DB offline
Connection proxy for connection pooling and multiplexing (Moxi)

Best used: Any application where low-latency data access, high concurrency support and high availability is a requirement.

For example: Low-latency use-cases like ad targeting or highly-concurrent web apps like online gaming (e.g. Zynga).

Of course, all systems have much more features than what’s listed here. I only wanted to list the key points that I base my decisions on. Also, development of all are very fast, so things are bound to change. I’ll do my best to keep this list updated.