NoSQL Databases

RDBMS focus attention on data consistency and compliance with a formal database schema.
New data cannot be added to a database unless it satisfies the type constraints of the relations involved.
The use of transactions which are all or nothing operations on databases are used to keep the database consistent at all times. (This is usually a desirable property.)
Often, though, for larger operations, this consistency incurs an overhead which harms scalability and flexibility.
There are limits to how much a system can be vertically scaled by either making a single machine faster or have more memory.
For these situations, we may need to add additional machines (horizontally scale), which is hard for RDBMSs to do at a large scale.
We now look at database systems which can horizontally scale (maybe by substituting eventual consistency for consistency) as well as handle semi-structured, rather than rigid structured data, under the general moniker of NoSQL database.
Think of NoSql as standing for Not-only SQL or Not-Only Relational model databases.
There are several different kinds of NoSQL databases: Key-Value Stores, Tuple and Document Stores, Column-Oriented Databases, and Graph-based Databases.
We begin by looking at Key-Value Stores.

Key Value Store

A key-value store saves data as a key-value pair.
Here keys are unique and represent the "search" criterion to retrieve the corresponding value.
The majority of programming languages of have a data structure as part of their libraries that can implement such a key value mapping at least for the duration of the program's running life-cycle.

For example, in Java we can use a HashMap:

import java.util.HashMap;
import java.util.Map;
public class KeyValueStoreExample {
    public static void main(String... args) {
      // Keep track of age based on name
       Map<String, Integer> age_by_name = new HashMap<>();
       // Store some entries
       age_by_name.put("wilfried", 34);
       age_by_name.put("seppe", 30);
       age_by_name.put("bart", 46);
       age_by_name.put("jeanne", 19);
       // Get an entry
       int age_of_wilfried = age_by_name.get("wilfried");
       System.out.println("Wilfried's age: " + age_of_wilfried);
       // Keys are unique
       age_by_name.put("seppe", 50); // Overrides previous entry
    }
}

From Keys to Hashing

To make the data structure of a hash map efficient, its keys ("bart", "seppe", etc in the previous example) are hashed by means of a hash function into a fixed-ranged hash value.
Since the range is smaller than the hash function's domain, two items can hash to the same value (pigeonhole principle).
A good hash function though should satisfy:
- deterministic - the same input to the hash function should always output the same hash value.
- uniform - the inputs should be mapped evenly over the output range.
- defined size - the output of the hash function should be of fixed size.
Below is an example of a possible hash mapping for the string names we saw into double-digit values:
A user wishing to retrieve the value for a key "bart", computes the hash function, looks at the output value row in the hash table, then finds the bart pair among the list of all items with that hash value.

Quiz

Which of the following is true?

Variables in XQuery must be proceeded with a question mark.
The typical format of a SparkQL query is a FLWOR expression.
A WSDL page might be read by a user agent to find out how to use a web service.

Horizontal Scaling

Hash table, key value stores are relatively easy to horizontally scale.
There is a limit to the number of key value pairs that can be stored on a single server.
We can, however, have multiple servers and use the hash value of the hash function select which server a key-value pair will be stored on.
For example, suppose we have three server. we can map the two digit hash value v of our hash function example of the previous slides to a server using v mod 3 +1 as shown in the diagram below:
There are other techniques besides hashing to distribute values over resources. One possibility is to use a separate routing server that distributes data over a cluster of resources.
Regardless of the technique, distributing data over server nodes means we partition the data into separate sets, one for each node.
This process is called sharding, and an individual partition is often called a shard.

Scaling a Web-site

I am going to spend the next few slides looking at a famous early example of a key-value store called Memcached.
To make things practical, I am going to talk about it in the context of how make a website go from handling a few thousand hits a day to thousands of hits per second.
You can think of this a scaling in a more generic sense rather than just horizontal scaling.
To make this term precise, we will say a web-site is scalable if:
- It can accommodate increased usage
- It can accommodate an increased dataset
- It is maintainable.
Throwing more hardware at a problem might help solve the first two points, but if the additional hardware makes the system to hard to manage three will fail.
Let's look at an example web-site architecture in terms of scalability.

Example Web-site Architecture (medium-large site ~5000 hits/sec)

Organization of a website show squids, http servers, memcached server, databases.

Remarks on Architecture

The diagram on the last slide only shows one master DB and many slaves.
The slaves would be read only and the master usually supports reads and writes. The slaves could be kept in sync with the master using rsync.
To handle even more data might have several master DBs and horizontally partition the data between them.
We will mainly look-at how to handle increase usage.
The reverse proxy in front of everything is typically implemented using Varnish, Squid, or a hardware specific system.
An advantage of a layer seven network appliance like a Netscaler, etc hardware over a Squid is that it can do SSL in hardware. On the other hand, hardware is harder to change. Many products nowadays run virtualized and cloudified as well.
We will focus today on how to handle increased database traffic where most of the traffic comes in the forms of reads.

Memcached

Memcached (http://memcached.org/) allows you to create an in memory cache of data.
It was originally developed by Brad Fitzpatrick at Livejournal in 2003. It is currently used by YouTube, Reddit, Facebook, Pinterest, Twitter, Wikipedia, etc.
You can use brew, apt, or choco to install memached.
A memcached can be on a separate server from either your database or your webserver.
Your app connects to the memcache daemon and checks if an item such as an object that might have been obtained from a database using an ORM mapping, is in the memcached. If it is you can get them quickly, if it isn't then you go to the database.

Running memcached

To run the memcached daemon one can type a line like:
```
memcached -d -m 50 -l 127.0.0.1 -p 11211
```
Here:
- -d -- as daemon
- -m -- number of megabytes
- -l -- location
- -p -- port
The original versions of memcached didn't have any security protocol, so the -l option is important -- it is allowing only traffic from the loopback network to connect to memcached.

Demo of connecting to memcached as a human - set

Memcached has two protocols for interacting with it: a text-based and a binary format.
We will demo connecting to memcache using telnet and the text-based protocol.

To connect and do a set we could do:

telnet 127.0.0.1 11211
set foo 0 0 6
lalala
STORED

Here set is the command.
foo is the key which we can use to look up the value we stored later.
The first 0 is a 16 or 32 bit (1.2.1 or higher), decimal written flag which could be used to optionally store info.
The second zero indicates the expiry time in seconds -- 0 means never expire.
The 6 indicates the number of bytes we'll store not including the final carriage return linefeeds which terminate the data block.
After these value we have a \r\n and then we begin the data block which is terminated with a \r\n.
Finally, memcached responds with STORED.
Other storage commands include: add, replace, append, and prepend.
There are also commands: delete, to delete entries, incr, decr to increment decrement the value associated with a key, and stats to output various statistics.

Demo of connecting to memcached as a human - get

To retrieve stored values, you can use either get followed by one or whitespace separated keys, or gets followed by one or more whitespace separated keys.
The server will respond with:
```
VALUE key flags bytes\r\n
data block\r\n
```
one for each value returned, followed by an END\r\n after the last value.
Continuing the example from the last slide we can type and get the response:
```
get foo
VALUE foo 0 6
lalala
END
```

Some Remarks on Memcached

Using CURL/sockets it would be possible to write a pure PHP/Java/Python program that connects with a memcache to store/retrieve values.
Instead, people usually use a language interface -- this is what is the secret sauce for mapping keys across multiple memcached servers.
These interfaces are allow for persistent (between requests) connections to a memcache.
Typically, memcached's are used as a distributed cache. If one has 50Mb free on each of ten machines, one adds the ten servers to the memcache objects in your language and it manages balancing and storing the key-value amongst these machines. This effectively would give you 500MB of total memory storage.
Memory in memcached is allocated using a slab system with slabs of various sizes. When a given pool of slabs fills an LRU algorithm, is used to determine who is bumped from memory.
It should be noted that there is a 1MB maximum on the size of an object you can store with a given key.
As one common use of memcached is to store objects from Object Relational Mapping (ORM), this limit usually does not cause a problem. The language extensions do the job of serializing/unserializing these objects before putting them in/retrieving them from a memcache.

Java Memcached Example

Below is an example of connecting to three memcached servers using the Java SpyMemcached Interface API:

import java.util.ArrayList;
import java.util.List;
import net.spy.memcached.AddrUtil;
import net.spy.memcached.MemcachedClient;

public class MemCachedExample {
    public static void main(String[] args) throws Exception {
        List<String> serverList = new ArrayList<String>() {
            {
                this.add("memcachedserver1.servers:11211");
                this.add("memcachedserver2.servers:11211");
                this.add("memcachedserver3.servers:11211");
            }
        };
        MemcachedClient memcachedClient = new MemcachedClient(
            AddrUtil.getAddresses(serverList));
        // ADD adds an entry and does nothing if the key already exists
        // Think of it as an INSERT
        // The second parameter (0) indicates the expiration - 0 means no expiry
        memcachedClient.add("marc", 0, 34);
        memcachedClient.add("seppe", 0, 32);
        memcachedClient.add("bart", 0, 66);
        memcachedClient.add("jeanne", 0, 19);
        // It is possible to set expiry dates: the following expires in three
        // seconds:
        memcachedClient.add("short_lived_name", 3, 19);
        // Sleep 5 seconds to make sure our short-lived name is expired
        Thread.sleep(1000 * 5);
        // SET sets an entry regardless of whether it exists
        // Think of it as an UPDATE-OR-INSERT
        memcachedClient.add("marc", 0, 1111);
        // <- ADD will have no effect
        memcachedClient.set("jeanne", 0, 12); // <- But SET will
        // REPLACE replaces an entry and does nothing if the key does not exist
        // Think of it as an UPDATE
        memcachedClient.replace("not_existing_name", 0, 12);
        // <- Will have no effect
        memcachedClient.replace("jeanne", 0, 10);
        // DELETE deletes an entry, similar to an SQL DELETE statement
        memcachedClient.delete("seppe");
        // GET retrieves an entry
        Integer age_of_marc = (Integer) memcachedClient.get("marc");
        Integer age_of_short_lived = (Integer) memcachedClient.get(
            "short_lived_name");
        Integer age_of_not_existing = (Integer) memcachedClient.get(
            "not_existing_name");
        Integer age_of_seppe = (Integer) memcachedClient.get("seppe");
        System.out.println("Age of Marc: " + age_of_marc);
        System.out.println("Age of Seppe (deleted): " + age_of_seppe);
        System.out.println("Age of not existing name: " + age_of_not_existing);
        System.out.println("Age of short lived name (expired): " +
            age_of_short_lived);
        memcachedClient.shutdown();
    }
}

Notice when we are using Memcached for adding, setting, replacing, getting, we don't need to say which server.

Request Coordination

Notice for memcached it is the client that figures out where to route requests to store and retrieve keys.
For more sophisticated systems such as Cassandra, BigTable, DynamoDB, CouchDB, Redis, CouchBase, etc, this routing is determined by the server nodes themselves.
In such a set-up, all nodes often implement the same functionality and can all perform the role of request coordinator -- the party responsible for directing a request to a node that can handle the request.
For this to work, it is necessary that all nodes remain informed at all times of the other nodes in the network.
A membership protocol is used to announce a node to the network, obtain a membership list, and to keep this list up-to-date.
Such a protocol consists of two parts: dissemination and failure detection.
Dissemination protocols can be as simple as doing a periodic multicast announcing ones existence (tends not to scale if every node is multicasting all theh time).
Another possibility is for machines to do periodic, pairwise communication between machines known to it (gossiping).
When a node is added to a network it contacts a known existing machine, when a node is removed or fails it no longer responds to gossip requests so is removed from other nodes' lists.
Given the above, each node knows its list of neighbors. Next day, we will describe how to do hashing of values within this list.

NoSQL Databases

Outline

NoSQL Databases

Key Value Store

From Keys to Hashing

Quiz

Horizontal Scaling

Scaling a Web-site

Example Web-site Architecture (medium-large site ~5000 hits/sec)

Remarks on Architecture

Memcached

Running memcached

Demo of connecting to memcached as a human - set

Demo of connecting to memcached as a human - get

Some Remarks on Memcached

Java Memcached Example

Request Coordination