Slick 3.0. Wie man Slick-Tupel-Tabelle meiner Domain-Klasse zuordnen kann?

Question

Ich möchte Zeilen nach Spalten filtern, die ich in meiner Domain-Klasse nicht sehen möchte. So zum Beispiel sieht meine Tabelle wie folgt aus:

class UserTable(tag: Tag) extends Table[(Int, String, Boolean)](tag, "users") { 

    def id = column[Int]("id") 

    def name = column[String]("name") 

    def active = column[Boolean]("active") 

    override def * = (id, name, active) 

    } 

Und meine Domain-Klasse wie folgt aus:

case class User(id: Int, name: String) 

Aus irgendeinem Grund will ich nicht active in meiner User Klasse angemeldet haben. Aber ich möchte Abfragen haben, die User als Ergebnis produziert. Und ich möchte keine Zukunftspläne abbilden. Wie folgt:

val activeUsers: Future[Seq[User]] = db.run(query.filter(_.active === true) /* how to convert it here? */) 

So konnte mein Problem auf zwei Arten gelöst werden. Definieren Sie UserTable wie UserTable[User] und noch irgendwie filtern Sie es durch active Spalte. Oder definieren Sie UserTable, wie es jetzt definiert ist, und konvertieren Sie Tupel in User Klasse. Ich bin mir fast sicher, dass die erste nicht möglich ist, aber die zweite sollte möglich sein. Wie macht man das?

Answer 1

Ich habe ein wenig mit Slick gespielt. Wenn ich etwas nicht vermisse, ist das, was mir unmöglich erschien, tatsächlich sehr einfach und ich kann Spalte verwenden, die in der Endklasse in Abfragen nicht vorhanden ist:

object SlickMain { 

    def main(args: Array[String]) { 

    import scala.concurrent.ExecutionContext.Implicits.global 

    val db = Database.forConfig("slick.db") 

    val query = TableQuery[UserTable] 

    await { 
     db.run(query ++= Seq(
     User(1, "first"), 
     User(2, "second") 
    )) 
    } 

    val users = for { 
     nonActiveUsers <- query.filter(_.active === false).result 
     _ <- DBIO.sequence(nonActiveUsers.map(us => query.filter(_.id === us.id).map(_.active).update(true))) 
    } yield nonActiveUsers 

    val firstResult: Seq[User] = await(db.run(users)) 
    println(s"First batch: $firstResult") 
    // prints vector with two users 

    val secondResult: Seq[User] = await(db.run(users)) 
    println(s"Second batch: $secondResult") 
    // prints empty vector 
    } 

    def await[T](f: => Future[T]) = Await.result(f, Duration.Inf) 

    class UserTable(tag: Tag) extends Table[User](tag, "users") { 

    def id = column[Int]("id") 

    def name = column[String]("name") 

    def active = column[Boolean]("active") 

    override def * = (id, name, active) <>(create, extract) 

    def create(t: (Int, String, Boolean)): User = User(t._1, t._2) 

    def extract(u: User): Option[(Int, String, Boolean)] = Some((u.id, u.name, false)) 

    } 

} 


case class User(id: Int, name: String)