model.scala

package slick

import scala.slick.driver.MySQLDriver.simple._

object A extends Table[(Int, String)]("a") {
  def id = column[Int]("id", O.PrimaryKey)
  def s = column[String]("s")
  def * = id ~ s
  def bs = AToB.filter(_.aId === id).flatMap(_.bFK)
}

object B extends Table[(Int, String)]("b") {
  def id = column[Int]("id", O.PrimaryKey)
  def s = column[String]("s")
  def * = id ~ s
  def as = AToB.filter(_.bId === id).flatMap(_.aFK)
}

object AToB extends Table[(Int, Int)]("a_to_b") {
  def aId = column[Int]("a")
  def bId = column[Int]("b")
  def * = aId ~ bId
  def aFK = foreignKey("a_fk", aId, A)(a => a.id)
  def bFK = foreignKey("b_fk", bId, B)(b => b.id)
}

object t {
  val A = new Table[(Int, String)]("a") {
    def id = column[Int]("id", O.PrimaryKey)
    def s = column[String]("s")
    def * = id ~ s
    def bs = AToB.filter(_.aId === id).flatMap(_.bFK)
  }

  val B = new Table[(Int, String)]("b") {
    def id = column[Int]("id", O.PrimaryKey)
    def s = column[String]("s")
    def * = id ~ s
    def as = AToB.filter(_.bId === id).flatMap(_.aFK)
  }

  val AToB = new Table[(Int, Int)]("a_to_b") {
    def aId = column[Int]("a")
    def bId = column[Int]("b")
    def * = aId ~ bId
    def aFK = foreignKey("a_fk", aId, A)(a => a.id)
    def bFK = foreignKey("b_fk", bId, B)(b => b.id)
}
}

Test.scala

"test1" should "test1" taggedAs(Tag("Test1")) in {
    db.withSession {implicit s: Session =>
      (A.ddl ++ B.ddl ++ AToB.ddl).drop
      object A extends Table[(Int, String)]("a") {
        def id = column[Int]("id", O.PrimaryKey)
        def s = column[String]("s")
        def * = id ~ s
        def bs = AToB.filter(_.aId === id).flatMap(_.bFK)
      }

      object B extends Table[(Int, String)]("b") {
        def id = column[Int]("id", O.PrimaryKey)
        def s = column[String]("s")
        def * = id ~ s
        def as = AToB.filter(_.bId === id).flatMap(_.aFK)
      }

      object AToB extends Table[(Int, Int)]("a_to_b") {
        def aId = column[Int]("a")
        def bId = column[Int]("b")
        def * = aId ~ bId
        def aFK = foreignKey("a_fk", aId, A)(a => a.id)
        def bFK = foreignKey("b_fk", bId, B)(b => b.id)
      }

      (A.ddl ++ B.ddl ++ AToB.ddl).create
      A.insertAll(1 -> "a", 2 -> "b", 3 -> "c")
      B.insertAll(1 -> "x", 2 -> "y", 3 -> "z")
      AToB.insertAll(1 -> 1, 1 -> 2, 2 -> 2, 2 -> 3)

      val q1 = for {
        a <- A if a.id >= 2
        b <- a.bs
      } yield (a.s, b.s)
      q1.foreach(x => println("  "+x))

    }
  }

"test2" should "test2" taggedAs(Tag("Test2")) in {
    db.withSession{ implicit s: Session =>
      import slick._ //Here we are importing the tables from another file. Same tables just different file
      (A.ddl ++ B.ddl ++ AToB.ddl).drop
      (A.ddl ++ B.ddl ++ AToB.ddl).create
      A.insertAll(1 -> "a", 2 -> "b", 3 -> "c")
      B.insertAll(1 -> "x", 2 -> "y", 3 -> "z")
      AToB.insertAll(1 -> 1, 1 -> 2, 2 -> 2, 2 -> 3)

      val q1 = for {
        a <- A if a.id >= 2
        b <- a.bs
      } yield (a.s, b.s)
      q1.foreach(x => println("  "+x))
      //    assertEquals(Set(("b","y"), ("b","z")), q1.list.toSet)
    }
  }

"test3" should "test3" taggedAs(Tag("Test3")) in {
    db.withSession{ implicit s: Session =>
      import slick.t._ //Here we are import the vals instead of the objects
      (A.ddl ++ B.ddl ++ AToB.ddl).drop
      (A.ddl ++ B.ddl ++ AToB.ddl).create
      A.insertAll(1 -> "a", 2 -> "b", 3 -> "c")
      B.insertAll(1 -> "x", 2 -> "y", 3 -> "z")
      AToB.insertAll(1 -> 1, 1 -> 2, 2 -> 2, 2 -> 3)

      val q1 = for {
        a <- A if a.id >= 2
        b <- a.bs
      } yield (a.s, b.s)
      q1.foreach(x => println("  "+x))
      //    assertEquals(Set(("b","y"), ("b","z")), q1.list.toSet)
    }
  }