Grokking Diesel, Rust's ORM

On rethinking this though, I'm wondering if the more performant way might be to provide a helper function that iterates over all returned rows, identifies when one record type in the result ends and another begins (the same steps you have to do to condense), but just executes a registered callback at that time. E.g. user_begin, user_end, post_begin, post_end, etc.

Although I should probably read up more on how Java/C/C# do this before spouting my half formed ideas about an area I'm not really informed in.... ;)

For instance this is an example from Diesel:

Post::belonging_to(user).load(&connection)

And this is how it would look like in Slick:

Post.filter(_.userID === 1).result

So both of the above would translate into SQL "SELECT * FROM posts WHERE user_id = 1", however Slick is more explicit whereas Diesel definitely feels like an ORM. The tripple equals in Slick example for instance is a nice touch and an example of operator overloading, because userID could be of type Integer or Option[Integer] (nullable field) and it would work both ways.

I do agree that things like associations are an entirely new layer of abstraction.

    val base = for {
      ur <- UserRole
       u <- ur.user
       r <- ur.role
    } yield (ur, u, r)

    val withManager = for {
      (ur, u, r) <- base
              ts <- TeamStaff if u.id === ts.userId
    } yield (ur, u, r, ts)

    val teams = for {
      (_, _, _, ts) <- withManager
                 t  <- Team if t.id === ts.teamId
    } yield (ts, t)

Quill, another Scala FRM library, is worth checking out in this regard, as is Haskell's Esqueleto.