Slick 3: how to drop and take on collections with some relations

Question

I'm working with Play! Scala 2.4 and Slick 3. I have a many to many relations as following:

  class Artists(tag: Tag) extends Table[Artist](tag, "artists") {
    def id = column[Long]("artistid", O.PrimaryKey, O.AutoInc)
    def name = column[String]("name")

     def * = (id.?, name) <> ((Artist.apply _).tupled, Artist.unapply)
  }

The relation table:

  class ArtistsGenres(tag: Tag) extends Table[ArtistGenreRelation](tag, "artistsgenres") {
    def artistId = column[Long]("artistid")
    def genreId = column[Int]("genreid")

    def * = (artistId, genreId) <> ((ArtistGenreRelation.apply _).tupled, ArtistGenreRelation.unapply)

    def aFK = foreignKey("artistid", artistId, artists)(_.id, onDelete = ForeignKeyAction.Cascade)
    def bFK = foreignKey("genreid", genreId, genres)(_.id, onDelete = ForeignKeyAction.Cascade)
  }

and the third table:

 class Genres(tag: Tag) extends Table[Genre](tag, "genres") {
    def id = column[Int]("genreid", O.PrimaryKey, O.AutoInc)
    def name = column[String]("name")

    def * = (id.?, name) <> ((Genre.apply _).tupled, Genre.unapply)
  }

Until now I just wanted to get all the artists by their genre names as following (and their genres as well):

  def findAllByGenre(genreName: String, offset: Int, numberToReturn: Int): Future[Seq[ArtistWithGenre]] = {
    val query = for {
      genre <- genres if genre.name === genreName
      artistGenre <- artistsGenres if artistGenre.genreId === genre.id
      artist <- artists joinLeft
        (artistsGenres join genres on (_.genreId === _.id)) on (_.id === _._1.artistId)

      if artist._1.id === artistGenre.artistId
    } yield artist


    db.run(query.result) map { seqArtistAndOptionalGenre => 
        ArtistsAndOptionalGenresToArtistsWithGenres(seqArtistAndOptionalGenre)
    }
  }

The method ArtistsAndOptionalGenresToArtistsWithGenres groups the response by artists. This worked like a charm. Now I want to limit the number of artists I get from the database.

But I don't manage to use correctly the slick functions take and drop: indeed as my query returns a list of artists and relations, If I add a take before the .result I don't receive the number of artists I want to get (depending of the number of relations the artists have).

I could drop and take after that I have grouped my result by artist, but I see a problem here: the SGBDR won't optimize the request, i.e. I will get all the artists (it can be a lot), proceed the groupBy and after take a bit instead of limit the number of artist returned before the groupBy.

Answer 1

I found the following solution (with 2 queries but 1 DB call):

def findAllByGenre(genreName: String, offset: Int, numberToReturn: Int): Future[Seq[ArtistWithWeightedGenres]] = {
    val query = for {
      genre <- genres.filter(_.name === genreName)
      artistGenre <- artistsGenres.filter(_.genreId === genre.id)
      artist <- artists.filter(_.id === artistGenre.artistId)

    } yield artist

    val artistsIdFromDB = query.drop(offset).take(numberToReturn) map (_.id)

    val query2 = for {
      artistWithGenres <- artists.filter(_.id in artistsIdFromDB) joinLeft
        (artistsGenres join genres on (_.genreId === _.id)) on (_.id === _._1.artistId)
    } yield artistWithGenres

    db.run(query2.result) map { seqArtistAndOptionalGenre =>
      ArtistsAndOptionalGenresToArtistsWithGenres(seqArtistAndOptionalGenre)
    } map(_.toVector)
  }

If anyone has a better solution...