ReQL provides the insert() function to create new documents in the table. Here is the code to do so.:

 rethinkdb.db('test','test').table('users','users').insert({
 userId : "shahid",
 password : "password123",
 createdDate : new Date()
 }).run(connection,function(err,response) { 
 if(err) {
 throw new Error(err);
 }
 console.log(response); 
 }); 

Upon running the code, RethinkDB returns the following.:

{ 
 deleted: 0, 
 errors: 0, 
 generated_keys: [ ''e54671a0'e54671a0-bdcc-44ab-99f3-90a44f0291f8'' ], 
 inserted: 1, 
 replaced: 0, 
 skipped: 0, 
 unchanged: 0 
 } 

Providing database details is optional in the query. The key to look for in the code is inserted, which determines whether the document was inserted or not. Since we are not providing the primary key from our side, RethinkDB generates it automatically and you can find that in the generated_keys.

You can add much more complex data in the RethinkDB than you can do in any other NoSQL database. You can also store nested objects, arrays, binary objects, and so on. We will look over binary objects in the upcoming section.

You can read the documents from the table using the get() or getAll() ReQL method. Here is a query to retrieve all the documents present in the table:

 rethinkdb.table('users','users').run(connection,function(err,cursor) { 
 if(err) { 
 throw new Error(err); 
 } 
 cursor.toArray(function(err,result) { 
 console.log(result); 
 }); 
 });

The preceding code performs the read operation in the table and returns you cursor. Cursor provides a batch of data in sequence instead of whole data at once. We use the toArray() function to read the information in the batch. It should print the following on the console:

[ {  
createdDate: 2016-06-09T08:58:15.324Z, 
id: ''e54671a0'e54671a0-bdcc-44ab-99f3-90a44f0291f8'', 
password: ''password123'''password123', 
userId: ''shahid'''shahid'  
} ] 

You can also read specific data based on the filter. Let's try to read the data with the uniquely generated ID the using the get() method as follows:

rethinkdb.table('users').get('e54671a0-bdcc-44ab-99f3-90a44f0291f8') 
 .run(connection,function(err,data) { 
if(err) { 
throw new Error(err); 
    } 
console.log(data); 
  }); 

It will return a single document from the table without the cursor. You can get the response in the callback variable.

As you may have noticed, we are directly accessing the table in the query without passing the database name because the connection variable contains the database information.

You can perform the update operation on the document using the update() function which accepts the object as an argument. You can at least update one key or the whole document (all keys) after fetching the document. Here is the code snippet to do so:

rethinkdb.table('users') 
    .get('e54671a0-bdcc-44ab-99f3-90a44f0291f8') 
    .update({userId : 'shahidShaikh'}) 
    .run(connection,function(err,response) { 
if(err) { 
throw new Error(err); 
      } 
console.log(response); 
   }); 

In order to update the document, we first fetch it using the get() method and then running the update() function. We are just updating the userId key here but you can pass other keys as well.

It will return the following on the console:

{  
deleted: 0, 
errors: 0, 
inserted: 0, 
replaced: 1, 
skipped: 0, 
unchanged: 0  
} 

The key to look for in the code is replaced, which, if it returns 1, means the update operation is successfully committed; otherwise, in the case of any other value, there is an error.

You can also use replace() ReQL method to replace the entire document with a new document. This method generates a new document and do not preserve the same ID as the update() method does.

You can validate the data by either running the get() method again or running the following code in the web administrative console:

r.db('test').table('users').get('e54671a0-bdcc-44ab-99f3-90a44f0291f8') 

We can use the delete() ReQL commands to perform a deletion. Again we need to fetch the record first and then perform the delete operation. You can perform a delete all operation as well by first fetching all documents. Here is the code to do so:

rethinkdb.table('users') 
    .get('e54671a0-bdcc-44ab-99f3-90a44f0291f8') 
    .delete() 
    .run(connection,function(err,response) { 
if(err) { 
throw new Error(err); 
      } 
console.log(response); 
    }); 

This should print the following on the terminal:

{  
deleted: 1, 
errors: 0, 
inserted: 0, 
replaced: 0, 
skipped: 0, 
unchanged: 0  
} 

You can check out the deleted key to know the status of the delete operation. If you want to delete all the documents from the database, you can do so by selecting all documents first and appending the delete() operation as follows:

rethinkdb.table('users') 
    .delete() 
    .run(connection,function(err,response) { 
if(err) { 
throw new Error(err); 
      } 
console.log(response); 
    });