RethinkDB provides client drivers for various programming languages. To explain, I am going to consider Node.js, and the steps are as follows:

The preceding simple code snippet written in Node.js is importing the rethinkdb module and connecting to the RethinkDB server on the default port. It returns the callback function...

Almost all ReQL queries are chainable. You can chain ReQL queries using the dot operator, just like you do with pipe in Unix. Data flows from left to right and data from one command is passed to the next one until the query gets executed. You can chain queries until your query is done.

Just like we performed some queries on the previous section, we chained the get() function with update() or delete() to perform the query.

Here is an example:

rethinkdb.table('users').delete(); 
rethinkdb.table('users').get('<<id>>').update({id : 10}); 
rethinkdb.db('test').table('users').distinct().count(); 

This way of design provides a natural way of reading and understanding queries. It's easy to learn, modify, and read.

Queries are formed in the client but will be sent to server for execution when you run them. This makes sure there is no network round trip and bandwidth allocation. This provides efficiency in query execution.

We also mentioned in Chapter 1, The RethinkDB Architecture and Data Model, that RethinkDB executes queries in a lazy manner. It only fetches the data asked and required for the query to complete. Here is an example:

r.db('test').table('users').limit(5) 

To perform this query, RethinkDB will look for only the five documents only in the users table. It will perform enough operations to perform the data collection requested in the query. This avoids extra computation costs and CPU cycles.

To provide the highest level of efficiency, RethinkDB automatically parallelizes the query as much as possible across the server, CPU cores, or even data centers. RethinkDB automatically processes the complex queries into stages, parallelizes them across clusters...

ReQL supports conditional queries using subqueries, expressions, and the lambda function. In this section, we will look at each one of them using sample code written in Node.js.

In order to perform these queries, I have populated our users table in the test database with some documents. Here is the query executed from the RethinkDB web administrative screen:

r.db('test').table('users').insert([{ 
name : "John", 
age : 24 
}, { 
name : "Mary", 
age : 32 
},{ 
name : "Michael", 
age : 28 
}]) 

Let us run a query to find out documents with an age greater than 30 years. We are going to execute the following code after getting a connection to the database, the same as we did in the former section:

rethinkdb.table('users').filter(function (user) {  
return...

ReQL provides the following functions to manipulate and search strings:

      rethinkdb.table("users").filter(function(user) { 
      return user("name").match("^J"); 
      }).run(connection,function(err,cursor) { 
      if(err) { 
      throw new Error(err); 
        } 
       cursor.toArray(function(err,data) { 
       console.log(data); 
        }); 
      }); 

MapReduce is the programming model to perform operations (mainly aggregation) on distributed sets of data across various clusters in different servers. This concept was coined by Google and was used in the Google file system initially and later was adopted by the open source Hadoop project.

MapReduce works by processing the data on each server and then combine it together to form a result set. It actually divides into two operations namely Map and Reduce.

In RethinkDB, MapReduce queries operate in three steps as follows:

So mainly it is a Group MapReduce (GMR) operation...

RethinkDB provides support to call an external API that returns data in a JSON object, which most of the large API provider do. You can call HTTP API directly from your database hence no need of writing piece of code to just call an API and then dump into database. RethinkDB also handles it asynchronously so performance won't be affected if the API takes a longer time.

Let us try one basic API call before moving ahead with storing those in our table. We all know and use OMDb for movies review. There is a website called http://omdbapi.com/ that provides APIs to find out the movie information present in the OMDB database. Let's call one with the following code to fetch information about the Avengers movie and see how it goes:

rethinkdb.http("http://www.omdbapi.com/?t=avengers&y=2015&plot=short&r=json").run(connection,function(err,data) { 
if(err) { 
throw new Error(err); 
  } 
console.log(data); 
}); 

You should be receiving...

As we have mentioned in this chapter about RethinkDB binary object support, let's look over how to use it using ReQL. The syntax to store binary objects differs from client to client. In Node.js it uses buffers to convert the stream into binary and we can use RethinkDB to insert that in a table.

Let us take an example from the preceding document. There is a key called Poster, which is the official poster of the movie in a JPEG image format. We can store the image directly in RethinkDB in a binary format.

Consider the following code:

rethinkdb.http("http://www.omdbapi.com/?t=avengers&y=2015&plot=short&r=json").run(connection,function(err,data) { 
if(err) { 
throw new Error(err); 
  } 
rethinkdb.table("movies").insert({ 
movieName :data.Title, 
posterImage :rethinkdb.http(data.Poster, {resultFormat : 'binary'}) 
  }).run(connection,function(err,data) { 
if(err) { 
throw new Error(err); 
    } 
console.log...

JOINS are one of the features of NoSQL databases. RethinkDB provides the ReQL functions to perform various types of JOINS, such as inner, outer, and so on. Please refer to Chapter 1, The RethinkDB Architecture and Data Model, to study this more in detail.