"Use-Cases for MRuby in a Database like ArangoDB" or "Can MRuby be the next PL/SQL?"

In the relational world, PL/SQL is used to store business/application logic inside the relational database. The same movement is currently happening in the NoSQL. Redis for example uses LUA script in its newest version (2.6), to allow developers to tweak Redis. There a lot of use-cases for a programming language in document-stores. Programming languages are used in various document stores like ArangoDB, CouchDB, MongoDB, or VoltDB. In my opinion in the following use-cases a suitable language like Ruby will be most handy.

Transactions: Quite a lot NoSQL databases, that implement transaction, use scripts to do so. While transaction in a RDBMS were long running processes, transactions in NoSQL database are short-running computations or modification. For example, Redis requires a complicated optimistic locking to simulate transactions. The same effect can much easier achieved with small script.

Business Logic: Document stores and also most graph databases store objects aka documents as JSON objects. One of the anti-patterns is to store an age field in these objects. It is very easy to compute the age from the birthday in the client. But even with such a simple example. there are pit-falls. What is the correct time-zone? How to handle a “is 18-year check” if the birthday is the 29.Feb? Instead of handling these corner-cases in each different client, it is much easier to implement them once and for all in the server.

Permission: With complex queries, permission handling can be a performance disaster. One easy solution is to wrap the query in the a script and handle permission there.

Graph Traversal: In order to implement complex graph queries, one either needs ascii arts or scripts to describe the traversal.

Different databases implement these use-cases using different languages like Lua, Erlang, or JavaScript. With this blog I would like to promote Ruby as a possible candidate for such tasks.

Using MRuby within ArangoDB

ArangoDB, like CouchDB, has a HTTP interface and uses JSON for document exchange. The internal Http-Server of ArangoDB uses data structures for request and responses that loosely resambles the WEBrick interface of Ruby.

I tried to implement the age example with ArangoDB using MRuby. The first step is to define the HttpResponse and HttpRequest – as @tisba pointed out, it will be much more Ruby-like when using attribute_reader, see here. I will rewrite this as soon as this issue with MRuby has been solved.

module Arango

class HttpRequest

def body()

return @body

end

def headers()

return @headers

end

def parameters()

return @parameters

end

def request_type()

return @request_type

end

def suffix()

return @suffix

end

and

module Arango

class HttpResponse

def content_type()

return @content_type

end

def content_type=(type)

@content_type = type

end

def body()

return @body

end

def body=(text)

@body = text.to_s

end

def status()

return @status

end

def status=(code)

@status = code.to_i

end

The AbstractServlet is also straight forward.

module Arango

class AbstractServlet

@@HTTP_OK = 200

@@HTTP_CREATED = 201

def service(req, res)

method = req.request_type

if method == "GET"

self.do_GET(req, res)

elsif method == "PUT"

self.do_PUT(req, res)

elsif method == "POST"

self.do_POST(req, res)

elsif method == "DELETE"

self.do_DELETE(req, res)

elsif method == "HEAD"

self.do_HEAD(req, res)

else

generate_unknown_method(req, res, method)

end

def do_GET(req, res)