On Saturday, 25 April 2015 at 05:16:21 UTC, Andrei Alexandrescu
wrote:
Found this on reddit a few days ago:
http://rob.conery.io/2015/04/17/rethinkdb-2-0-is-amazing/
A good discussion of the pros and cons of pipeline-style
queries (the ReQL query language reminiscent of D's
algorithms/ranges) vs. classic SQL.
Andrei
I think his example of composability is targeting the exact
examples where ReQL is composable and SQL isn't. It's easy enough
to create an opposite example: let's say that our initial query
is this:
select vendor.name from vendor
inner join catalog on vendor.id = catalog.vendor_id
inner join details on details.catalog_id = catalog.id
r.db("music").table("catalog").map(function(album){
return {
artist : album("vendor")("name")
}
})
If we want to add the `type_id = 2` filter, in SQL it's a matter
of appending a line:
select vendor.name from vendor
inner join catalog on vendor.id = catalog.vendor_id
inner join details on details.catalog_id = catalog.id
where details.media_type_id = 2;
But in ReQL you'd have to insert the filter in the middle:
r.db("music").table("catalog").filter(function(album){
return album("details").filter(function(track){
return track("media_type_id").eq(2)
})
}).map(function(album){
return {
artist : album("vendor")("name")
}
})
So, composablity seems to be just a matter of where the part you
want to add happens to be placed in the query's structure...
At this point one might claim that in the SQL case we had to
modify a string while in the ReQL case we could simply use
methods of the existing query object - but that's because the
ReQL query is wrapped for us(the actual format sent to the server
is not the one written in the source code) while the SQL
isn't(OK, that's a lie - the SQL query is compiled to some more
efficient format. But that happens in the driver/server, so the
bindings don't have to do it). In reality SQL is also wrapped,
either by entirely new languages(ORMs like Hibernate) or by query
builders that let you use SQL almost directly, and simply make it
more convenient(I had good experience with
PetaPoco(http://www.toptensoftware.com/petapoco/), for example).
If you use these wrappers you get the same composability as
ReQL(modify query by invoking methods of existing query objects).
