After a bit of struggle because multiple dispatch, I ended up with what seems like a more Julian approach, overloading the + operator:
select(...) + from(...) + where(...) + limit(...)
Wondering if there’s a better way to implement method chaining in Julia?
However, when the API is used, it becomes verbose again as I have to prefix the methods with the module name (I don’t want to export the methods as the names are very common and would lead to name clashes – nor am I happy with const QB = QueryBuilder, still ugly). So I end up with:
.select(...) + .from(...) + .where(...) + .limit(...)
Is it possible to write a similar @with macro in Julia? My first attempts failed because Julia complains when I try to build an expression which starts with a dot: ERROR: syntax: invalid identifier name ".". So I’m not sure how to attack this…
I feel => will be better than + as most of us will interpret + as some kind of addition while => is much more intuitive.
Eg: select(...) => from(...) => where(...) => limit(...) (Or should it be in opposite order??)
MXNet uses something similar to chain layers in neural networks (https://github.com/dmlc/MXNet.jl)
One thing that I didn’t mention was that these methods can be chained in any order. This is one of the benefits of using a query builder versus just concatenating the parts of the actual query string. And this was also the reason for turning to fluent interfaces: so I wouldn’t have to manage a large number of combinations between different types (in my case, every method returns an instance of QueryPart).
@v-i-s-h in this regard I believe that + better reflects the commutative nature of the operation and the fact that the types are the same (one does not lead to the next).
@pdeffebach my issue has to do with scoping all the “dot” operations to an object – I can’t see a similar syntax with Lazy, can you give me an example, please?
@Raf That’s interesting - if it’s not possible to have an expression that starts with a . I could potentially “bootstrap” the expression. It can’t be select(...) as the methods can be chained in any order and they’re not required (select(...) can be absent, meaning SELECT *). But something like: @with QueryBuilder.from(...).order(...).limit(...)
could be a good starting point.
But it seems like you need to be very clear if you are making a macro-based DSL or using pure julia. Because the approach and syntax could be totally different. If your using a custom macro, you seem to be leaning to a DSL. So you may as well make it really clean syntax or its kind of a waste of using a macro.
So you don’t need the @with QueryBuilder part or the + or anything, just add them with the macro. You could swap the dots for spaces to use args in the macro, and you wont even have to parse much AST. Otherwise maybe don’t use a macro, its not worth the confusion and weirdness…
@qb select(...) from(...) where(...) limit(...)
That does seem like macro overkill, though there’s probably some reason…
Inside a macro those are just symbols :where etc and name space doesn’t matter, you can append or whatever to them if you have to keep them later in userspace (I have no idea what kind of transformation you actually have to do with them…)
You could have a macro that converts from @qr select(...) where(...) from(...) to QR.select(...) + QR.where(...) + QR.from(...). This way if people don’t want to use the macro they can still use a convenient interface.