Start the server

For a more detailed look, make sure to read the quickstart.

Linux and OS X

Start the server from a terminal window.

$ rethinkdb

Windows

Start the server from the Windows command prompt.

C:\Users\Slava\RethinkDB\>rethinkdb.exe

Import the driver

First, start a Ruby shell:

$ irb

Then, import the RethinkDB driver:

require 'rethinkdb'
include RethinkDB::Shortcuts

You can now access RethinkDB commands through the r module.

Open a connection

When you first start RethinkDB, the server opens a port for the client drivers (28015 by default). Let’s open a connection:

r.connect(:host=>"localhost", :port=>28015).repl

The repl command is a convenience method that sets a default connection in your shell so you don’t have to pass it to the run command to run your queries.

Create a new table

By default, RethinkDB creates a database test. Let’s create a table authors within this database:

r.db("test").table_create("authors").run

The result will be:

{
    :config_changes => [
        <table configuration data>
    ],
    :tables_created => 1
}

(The config_changes field contains metadata about the newly created table; for more details, read about the table_create command.) There are a couple of things you should note about this query:

• First, we select the database test with the db command.
• Then, we add the table_create command to create the actual table.
• Lastly, we call run in order to send the query to the server.

All ReQL queries follow this general structure. Now that we’ve created a table, let’s insert some data!

Insert data

Let’s insert three new documents into the authors table:

r.table("authors").insert([
    { "name"=>"William Adama", "tv_show"=>"Battlestar Galactica",
      "posts"=>[
        {"title"=>"Decommissioning speech", "content"=>"The Cylon War is long over..."},
        {"title"=>"We are at war", "content"=>"Moments ago, this ship received..."},
        {"title"=>"The new Earth", "content"=>"The discoveries of the past few days..."}
      ]
    },
    { "name"=>"Laura Roslin", "tv_show"=>"Battlestar Galactica",
      "posts"=>[
        {"title"=>"The oath of office", "content"=>"I, Laura Roslin, ..."},
        {"title"=>"They look like us", "content"=>"The Cylons have the ability..."}
      ]
    },
    { "name"=>"Jean-Luc Picard", "tv_show"=>"Star Trek TNG",
      "posts"=>[
        {"title"=>"Civil rights", "content"=>"There are some words I've known since..."}
      ]
    }
]).run

We should get back an object that looks like this:

{
    "unchanged"=>0,
    "skipped"=>0,
    "replaced"=>0,
    "inserted"=>3,
    "generated_keys"=>[
        "71879b1b-e81e-48c4-a42c-f41f83d7133e",
        "f0a93ef3-cec0-4364-bde6-f664088b9e77",
        "f601347b-95a1-4ffe-83bd-ed04d4a3cce5"
    ],
    "errors"=>0,
    "deleted"=>0
}

The server should return an object with zero errors and three inserted documents. We didn’t specify any primary keys (by default, each table uses the id attribute for primary keys), so RethinkDB generated them for us. The generated keys are returned via the generated_keys attribute.

There are a couple of things to note about this query:

• Each connection sets a default database to use during its lifetime (if you don’t specify one in connect, the default database is set to test). This way we can omit the db('test') command in our query. We won’t specify the database explicitly from now on, but if you want to prepend your queries with the db command, it won’t hurt.
• The insert command accepts a single document or an array of documents if you want to batch inserts. We use an array in this query instead of running three separate insert commands for each document.

Retrieve documents

Now that we inserted some data, let’s see how we can query the database!

All documents in a table

To retrieve all documents from the table authors, we can simply run the query r.table('authors'):

cursor = r.table("authors").run
cursor.each{|document| p document}

The query returns the three previously inserted documents, along with the generated id values.

Since the table might contain a large number of documents, the database returns a cursor object. As you iterate through the cursor, the server will send documents to the client in batches as they are requested. The cursor is an iterable Ruby object so you can go through all of the results with a simple for loop.

Filter documents based on a condition

Let’s try to retrieve the document where the name attribute is set to William Adama. We can use a condition to filter the documents by chaining a filter command to the end of the query:

cursor = r.table("authors").filter{|author| author["name"].eq("William Adama") }.run
cursor.each{|document| p document}

This query returns a cursor with one document—the record for William Adama. The filter command evaluates the provided condition for every row in the table, and returns only the relevant rows. Here’s the new commands we used to construct the condition above:

• author refers to the currently visited document.
• author['name'] refers to the value of the field name of the visited document.
• The eq command returns true if two values are equal (in this case, the field name and the string William Adama).

Let’s use filter again to retrieve all authors who have more than two posts:

cursor = r.table("authors").filter{|author| author["posts"].count > 2}.run
cursor.each{|document| p document}

In this case, we’re using a predicate that returns true only if the length of the array in the field posts is greater than two. This predicate contains two commands we haven’t seen before:

• The count command returns the size of the array.
• The > operator is overloaded by the RethinkDB driver to execute on the server. It returns True if a value is greater than a certain value (in this case, if the number of posts is greater than two).

Retrieve documents by primary key

We can also efficiently retrieve documents by their primary key using the get command. We can use one of the ids generated in the previous example:

r.db('test').table('authors').get('7644aaf2-9928-4231-aa68-4e65e31bf219').run

Since primary keys are unique, the get command returns a single document. This way we can retrieve the document directly without iterating through a cursor.

Realtime feeds

RethinkDB inverts the traditional database architecture by exposing an exciting new access model – instead of polling for changes, the developer can tell RethinkDB to continuously push updated query results to applications in realtime.

To start a feed, open a new terminal and open a new RethinkDB connection. Then, run the following query:

cursor = r.table("authors").changes.run
cursor.each{|document| p document}

Now switch back to your first terminal. We’ll be updating and deleting some documents in the next two sections. As we run these commands, the feed will push notifications to your program. The code above will print the following messages in the second terminal:

{
  "new_val": {
    "id": "1d854219-85c6-4e6c-8259-dbda0ab386d4",
    "name": "Laura Roslin",
    "posts": [...],
    "tv_show": "Battlestar Galactica",
    "type": "fictional"
  },
  "old_val": {
    "id": "1d854219-85c6-4e6c-8259-dbda0ab386d4",
    "name": "Laura Roslin",
    "posts": [...],
    "tv_show": "Battlestar Galactica"
  }
}

RethinkDB will notify your program of all changes in the authors table and will include the old value and the new value of each modified document. See the changefeeds documentation entry for more details on how to use realtime feeds in RethinkDB.

Update documents

Let’s update all documents in the authors table and add a type field to note that every author so far is fictional:

r.table("authors").update({"type"=>"fictional"}).run

Since we changed three documents, the result should look like this:

{
    "unchanged"=>0,
    "skipped"=>0,
    "replaced"=>3,
    "inserted"=>0,
    "errors"=>0,
    "deleted"=>0
}

Note that we first selected every author in the table, and then chained the update command to the end of the query. We could also update a subset of documents by filtering the table first. Let’s update William Adama’s record to note that he has the rank of Admiral:

r.table("authors").
    filter{|author| author["name"].eq("William Adama")}.
    update({"rank"=>"Admiral"}).run

Since we only updated one document, we get back this object:

{
    "unchanged"=>0,
    "skipped"=>0,
    "replaced"=>1,
    "inserted"=>0,
    "errors"=>0,
    "deleted"=>0
}

The update command allows changing existing fields in the document, as well as values inside of arrays. Let’s suppose Star Trek archaeologists unearthed a new speech by Jean-Luc Picard that we’d like to add to his posts:

r.table('authors').filter{|author| author["name"].eq("Jean-Luc Picard")}.
    update{|author| {"posts"=>author["posts"].append({
        "title"=>"Shakespeare",
        "content"=>"What a piece of work is man..."})
    }}.run

After processing this query, RethinkDB will add an additional post to Jean-Luc Picard’s document.

Delete documents

Suppose we’d like to trim down our database and delete every document with less than three posts (sorry Laura and Jean-Luc):

r.table("authors").
    filter{ |author| author["posts"].count < 3 }.
    delete.run

Since we have two authors with less than two posts, the result is:

{
    "unchanged"=>0,
    "skipped"=>0,
    "replaced"=>0,
    "inserted"=>0,
    "errors"=>0,
    "deleted"=>2
}

Learn more

Note: The RethinkDB Ruby driver includes support for asynchronous connections using EventMachine. Read the asynchronous connections documentation for more information.