Sacramento Ruby Meetup

Intro talk to RethinkDB given at Sacramento Ruby Meetup.

Transcript

1. RethinkDB The database for the realtime web Sacramento Ruby Meetup Sacramento, California May 21, 2015
2. Jorge Silva @thejsj Developer Evangelist @ RethinkDB
3. Preface Why is realtime important?
4. Realtime apps • More and more apps are built to be realtime • Users have come to want and expect this behavior in their apps
5. Realtime apps
6. Realtime apps
7. Introduction What is RethinkDB?
8. What is RethinkDB? • Open source database for building realtime web applications • NoSQL database that stores schemaless JSON documents • Distributed database that is easy to scale
9. Built for Realtime Apps • Subscribe to change notifications from database queries • No more polling — the database pushes changes to your app • Reduce the amount of plumbing needed to stream live updates
10. RethinkDB Structure Database → Table → Document MySQL: Database → Table → Row MongoDB: Database → Collection → Document
11. Sample Document { "name": "Will Riker", "position": "Commander", "height": 193, "birthdate": Mon Aug 19 2335, "ships": [ { "name": "USS Pegasus" }, { "name": "USS Potemkin" }, { "name": "USS Enterprise" }, ], ... }
12. Introduction to ReQL RethinkDB Query Language
13. Introduction to ReQL • ReQL embeds natively into your programming language • Compose ReQL queries by chaining commands
14. Anatomy of a ReQL Query r.table("users") .pluck("last_name") .distinct().count() Number of unique last names
15. Anatomy of a ReQL Query r.table("users") .pluck("last_name") .distinct().count() Access a database table
16. Anatomy of a ReQL Query r.table("users") .pluck("last_name") .distinct().count() Isolate a document property
17. Anatomy of a ReQL Query r.table("users") .pluck("last_name") .distinct().count() Consolidate duplicate values
18. Anatomy of a ReQL Query r.table("users") .pluck("last_name") .distinct().count() Display the number of items
19. Sample ReQL Queries r.table("user") .filter(r.row(“age") > (30)) r.table(“post") .eq_join(“u_id”, r.table(“user”)) .zip() r.table("fellowship") .filter({:species => "hobbit"}) .update({:species => "halfling"})
20. ReQL Commands • Transformations: map, orderBy, skip, limit, slice • Aggregations: group, reduce, count, sum, avg, min, max, distinct, contains • Documents: row, pluck, without, merge, append, difference, keys, hasFields, spliceAt • Writing: insert, update, replace, delete
21. Understanding ReQL • Client driver translates ReQL queries into wire protocol • In Ruby, the driver users operator overloading for most operations (+, /, >=, not)
22. Additional ReQL Features • Geospatial indexing for location- based queries • Date and time functions for time data • Support for storing binary objects
23. Running Queries https://github.com/thejsj/rethinkdb-workshop
24. http://rethinkdb-chat.thejsj.com:10001/ Running Queries
25. Realtime updates Working with Changefeeds
26. Subscribe to change notifications on database queries Changefeeds
27. r.table("users").changes() Track changes on the users table Changefeeds
28. Changefeeds • The changes command returns a cursor that receives updates • Each update includes the new and old value of the modified record
29. Changefeeds r.table("users").changes() r.table("users") .insert({name: "Bob"}) Changefeed output: { new_val: { id: '362ae837-2e29-4695-adef-4fa415138f90', name: 'Bob', ... }, old_val: null }
30. Changefeeds r.table("users").changes() r.table("users") .filter({name: "Bob"}).delete() Changefeed output: { new_val: null, old_val: { id: '362ae837-2e29-4695-adef-4fa415138f90', name: 'Bob', ... } }
31. Changefeeds r.table("users").changes() r.table("users") .get("362ae837-2e29-4695-adef-4fa415138f90") .update({name: "Bobby"}) Changefeed output: { new_val: { id: '362ae837-2e29-4695-adef-4fa415138f90', name: 'Bobby' }, old_val: { id: '362ae837-2e29-4695-adef-4fa415138f90', name: 'Bob' } }
32. Changefeeds r.table("players") .orderBy({index: r.desc("score")}) .limit(3).changes() Track top three players by score Chain the changes command to an actual ReQL query:
33. Changefeeds r.table("table").get(ID).changes() r.table("table").get_all(ID).changes() r.table("table").between(X, Y).changes() r.table("table").filter(CONDITION).changes() r.table("table").union(ID).changes() r.table("table").map(FUNCTION).changes() r.table("table").min(INDEX).changes() r.table("table").max(INDEX).changes() r.table("table").order_by(INDEX) .limit(N).changes() Commands that currently work with changefeeds:
34. Using changefeeds
35. Building web apps Realtime apps in Ruby
36. Demo
37. Basic REST application class MessageApp < Sinatra::Base set :public_folder, 'client' get "/" do; ...; end get '/messages' do; ...; end post '/messages' do; ...; end end Rack::Server.start app: MessageApp, Port: 8000
38. Basic REST application class MessageApp < Sinatra::Base set :public_folder, 'client' get "/" do; ...; end get '/messages' do; ...; end post '/messages' do; ...; end end Rack::Server.start app: MessageApp, Port: 8000 Create a Sinatra app
39. Basic REST application class MessageApp < Sinatra::Base set :public_folder, 'client' get "/" do; ...; end get '/messages' do; ...; end post '/messages' do; ...; end end Rack::Server.start app: MessageApp, Port: 8000 Route to static assets
40. Basic REST application class MessageApp < Sinatra::Base set :public_folder, 'client' get "/" do; ...; end get '/messages' do; ...; end post '/messages' do; ...; end end Rack::Server.start app: MessageApp, Port: 8000 Create a route to get messages
41. Basic REST application class MessageApp < Sinatra::Base set :public_folder, 'client' get "/" do; ...; end get '/messages' do; ...; end post '/messages' do; ...; end end Rack::Server.start app: MessageApp, Port: 8000 Create a route to post messages
42. Basic REST application class MessageApp < Sinatra::Base set :public_folder, 'client' get "/" do; ...; end get '/messages' do; ...; end post '/messages' do; ...; end end Rack::Server.start app: MessageApp, Port: 8000 Start app in port 8000
43. Let's convert this app into a realtime app
44. What we need • Listen to changes in our data • Push data changes to our client
45. What we will use • RethinkDB as our database, to push data • EventMachine to perform asynchronous queries • Faye for realtime communication with clients
46. EventMachine • Event-driven programming • Non-blocking network I/O • Well-suited for the realtime Web
47. Faye Framework • Open source pub/sub framework for realtime messaging • Communication between frontend and backend • Supports Ruby and Node.js on the backend
48. RethinkDB + Faye EM.run do Conn = r.connect host: "localhost" class MessageApp < Sinatra::Base ... end App = Faye::RackAdapter.new MessageApp, mount: "/faye" r.table("messages").changes.em_run(Conn) do |err, change| App.get_client.publish('/messages/new', change["new_val"]) end Rack::Server.start app: App, Port: 8000 end Server-side Ruby code
49. RethinkDB + Faye EM.run do Conn = r.connect host: "localhost" class MessageApp < Sinatra::Base ... end App = Faye::RackAdapter.new MessageApp, mount: "/faye" r.table("messages").changes.em_run(Conn) do |err, change| App.get_client.publish('/messages/new', change["new_val"]) end Rack::Server.start app: App, Port: 8000 end Create EventMachine event loop
50. RethinkDB + Faye EM.run do Conn = r.connect host: "localhost" class MessageApp < Sinatra::Base ... end App = Faye::RackAdapter.new MessageApp, mount: "/faye" r.table("messages").changes.em_run(Conn) do |err, change| App.get_client.publish('/messages/new', change["new_val"]) end Rack::Server.start app: App, Port: 8000 end Connect to the database
51. RethinkDB + Faye EM.run do Conn = r.connect host: "localhost" class MessageApp < Sinatra::Base ... end App = Faye::RackAdapter.new MessageApp, mount: "/faye" r.table("messages").changes.em_run(Conn) do |err, change| App.get_client.publish('/messages/new', change["new_val"]) end Rack::Server.start app: App, Port: 8000 end Add your Sinatra app
52. RethinkDB + Faye EM.run do Conn = r.connect host: "localhost" class MessageApp < Sinatra::Base ... end App = Faye::RackAdapter.new MessageApp, mount: "/faye" r.table("messages").changes.em_run(Conn) do |err, change| App.get_client.publish('/messages/new', change["new_val"]) end Rack::Server.start app: App, Port: 8000 end Initialize Faye and bind URL route
53. RethinkDB + Faye EM.run do Conn = r.connect host: "localhost" class MessageApp < Sinatra::Base ... end App = Faye::RackAdapter.new MessageApp, mount: "/faye" r.table("messages").changes.em_run(Conn) do |err, change| App.get_client.publish('/messages/new', change["new_val"]) end Rack::Server.start app: App, Port: 8000 end Start the changefeed
54. RethinkDB + Faye EM.run do Conn = r.connect host: "localhost" class MessageApp < Sinatra::Base ... end App = Faye::RackAdapter.new MessageApp, mount: "/faye" r.table("messages").changes.em_run(Conn) do |err, change| App.get_client.publish('/messages/new', change["new_val"]) end Rack::Server.start app: App, Port: 8000 end Publish the update to a channel
55. RethinkDB + Faye EM.run do Conn = r.connect host: "localhost" class MessageApp < Sinatra::Base ... end App = Faye::RackAdapter.new MessageApp, mount: "/faye" r.table("messages").changes.em_run(Conn) do |err, change| App.get_client.publish('/messages/new', change["new_val"]) end Rack::Server.start app: App, Port: 8000 end Start Faye app on port 8000
56. RethinkDB + Faye faye.subscribe("/messages/new", function(message) { messageCollection.push(message); }); Client-side JavaScript code
57. Realtime Chat
58. Summary • RethinkDB inverts the database model by pushing data to your app • By doing this, your database remains as your central source of truth • Having a database that listens to changes in your data dramatically simplifies building realtime apps
59. Additional Resources • RethinkDB website:
 http://rethinkdb.com • RethinkDB cookbook:
 http://rethinkdb.com/docs/cookbook • RethinkDB installation:
 http://rethinkdb.com/docs/install/
60. Questions?