scala slick Methode, die ich nicht verstehen kann, so weit

[UPDATE] - Hinzugefügt (noch einer) Erklärung auf for Verstehens

1. Den * Methode:

   Dieser gibt die Standard-Projektion - das ist, wie Sie beschreiben:

   'alle Spalten (oder berechnete Werte) ich bin in der Regel interessiert".

   Ihre Tabelle könnte einige Felder; Sie müssen nur eine Teilmenge für
   Ihre Standard-Projektion. Die Standard-Projektion muss mit dem Typ
   Parameter der Tabelle.

   Nehmen wir es ein zu einer Zeit. Ohne die <> Sachen, nur die *:

   //First take: Only the Table Defintion, no case class:
   
   object Bars extends Table[(Int, String)]("bar") {
     def id = column[Int]("id", O.PrimaryKey, O.AutoInc)
     def name = column[String]("name")
   
     def * = id ~ name //Note: Just a simple projection, not using .? etc
   }
   
   //Note that the case class 'Bar' is not to be found. This is 
   //an example without it (with only the table definition)

   Nur eine Tabelle definition wie, dass machen Sie mit Anfragen wie:

   implicit val session: Session = //... a db session obtained from somewhere
   
   //A simple select-all:
   val result = Query(Bars).list   //result is a List[(Int, String)]

   die Standard-Projektion (Int, String) führt zu einer List[(Int, String)]
   für einfache Abfragen wie diese.

   //SELECT b.name, 1 FROM bars b WHERE b.id = 42;
   val q = 
      for (b <- Bars if b.id === 42) 
        yield (b.name ~ 1)
        //yield (b.name, 1) //this is also allowed: 
                             //tuples are lifted to the equivalent projection.

   Was ist der Typ von q? Es ist ein Query mit der Projektion (String, Int).
   Wenn Sie aufgerufen wird, gibt es eine List von (String, Int) Tupel als pro die Projektion.

    val result: List[(String, Int)] = q.list

   In diesem Fall müssen Sie festgelegt haben, die Projektion, die Sie wollen in der yield - Klausel
   der for Verständnis.

2. Nun über <> und Bar.unapply.

   Diese bietet sogenannte Zugeordnet Projektionen.

   Bisher haben wir gesehen, wie slick, können Sie express-Abfragen in Scala
   diese Rückkehr ein Projektion der Spalten (oder berechnete Werte); So bei der Ausführung
   diese Abfragen Sie haben zu denken, das Ergebnis Zeile einer Abfrage als Scala-Tupel.
   Der Typ der Tupel entsprechen der Projektion definiert ist (durch Ihre
   for Verständnis wie im vorherigen Beispiel, der durch die Standard - * Projektion).
   Dies ist der Grund, warum field1 ~ field2 gibt eine Projektion der Projection2[A, B] wo
   A ist die Art der field1 und B ist die Art der field2.

   q.list.map {
     case (name, n) =>  //do something with name:String and n:Int
   }
   
   Queury(Bars).list.map {
     case (id, name) =>  //do something with id:Int and name:String 
   }

   Beschäftigen wir uns mit Tupel, das kann umständlich sein, wenn wir zu viele haben
   Spalten. Wir hoffen, dass die Ergebnisse nicht als TupleN sondern einige
   Objekt mit benannten Feldern.

   (id ~ name)  //A projection
   
   //Assuming you have a Bar case class:
   case class Bar(id: Int, name: String) //For now, using a plain Int instead
                                         //of Option[Int] - for simplicity
   
   (id ~ name <> (Bar, Bar.unapply _)) //A MAPPED projection
   
   //Which lets you do:
   Query(Bars).list.map ( b.name ) 
   //instead of
   //Query(Bars).list.map { case (_, name) => name }
   
   //Note that I use list.map instead of mapResult just for explanation's sake.

   Wie funktioniert das? <> nimmt eine Projektion Projection2[Int, String] und
   gibt eine Gemappte Projektion auf die Art Bar. Die beiden Argumente Bar, Bar.unapply _
   sagen, slick, wie diese (Int, String) Projektion zugeordnet werden müssen, um einen Fall Klasse.

   Dies ist ein zwei-Wege-mapping; Bar ist der Fall Konstruktor der Klasse, so dass die
   Informationen, die benötigt werden, um zu gehen von (id: Int, name: String) zu einem Bar. Und unapply
   wenn Sie haben es erraten, ist für die Rückseite.

   Wo kommt unapply kommen? Dies ist ein standard-Scala-Methode verfügbar für
   jeder gewöhnliche Fall Klasse - nur die Definition Bar gibt Ihnen eine Bar.unapply die
   ist ein extractor, die verwendet werden können, um wieder die id und name dass die
   Bar gebaut wurde mit:

   val bar1 = Bar(1, "one")
   //later
   val Bar(id, name) = bar1  //id will be an Int bound to 1,
                             //name a String bound to "one"
   //Or in pattern matching
   val bars: List[Bar] = //gotten from somewhere
   val barNames = bars.map {
     case Bar(_, name) => name
   }
   
   val x = Bar.unapply(bar1)  //x is an Option[(String, Int)]

   Also Ihre Standard-Projektion zugeordnet werden können und die Falle Klasse, die Sie am meisten erwarten:

   object Bars extends Table[Bar]("bar") {
     def id = column[Int]("id", O.PrimaryKey, O.AutoInc)
     def name = column[String]("name")
     def * = id ~ name <>(Bar, Bar.unapply _)
   }

   Oder du kannst sogar pro-Abfrage:

   case class Baz(name: String, num: Int)
   
   //SELECT b.name, 1 FROM bars b WHERE b.id = 42;
   val q1 = 
      for (b <- Bars if b.id === 42) 
        yield (b.name ~ 1 <> (Baz, Baz.unapply _))

   Hier ist die Art der q1 ist ein Query mit einem zugeordnet Projektion zu Baz.
   Wenn Sie aufgerufen wird, gibt es eine List von Baz Objekte:

    val result: List[Baz] = q1.list

3. Schließlich, wie nebenbei, die .? bietet Option Heben - die Scala Art
   Umgang mit Werten, das kann nicht sein.

    (id ~ name)   //Projection2[Int, String] //this is just for illustration
    (id.? ~ name) //Projection2[Option[Int], String]

   Denen, Nachbereitung, wird gut funktionieren mit Ihrem original-definition von Bar:

   case class Bar(id: Option[Int] = None, name: String)
   
   //SELECT b.id, b.name FROM bars b WHERE b.id = 42;
   val q0 = 
      for (b <- Bars if b.id === 42) 
        yield (b.id.? ~ b.name <> (Bar, Bar.unapply _))
   
   
   q0.list //returns a List[Bar]

4. Antwort auf den Kommentar wie Slick verwendet for Verstehens:

   Irgendwie Monaden immer wieder schaffen, sich zu zeigen und Nachfrage
   Teil der Erklärung sein...

   Für Verstehens sind nicht auf bestimmte Kollektionen nur.
   Sie können verwendet werden, auf jede Art von Monade und Sammlungen sind
   nur eine der vielen Arten von Monaden-Typen in Scala.

   Aber als Sammlungen vertraut sind, Sie machen einen guten Anfang
   Punkt für eine Erklärung:

   val ns = 1 to 100 toList; //Lists for familiarity
   val result = 
     for { i <- ns if i*i % 2 == 0 } 
       yield (i*i)
   //result is a List[Int], List(4, 16, 36, ...)

   In Scala, eine für das Verständnis ist syntaktischer Zucker für
   Methode (evtl. geschachtelte) Methodenaufrufe: Der obige code
   ist (mehr oder weniger) gleichwertig zu:

   ns.filter(i => i*i % 2 == 0).map(i => i*i)

   Im Grunde nichts mit filtermapflatMap
   Methoden (in anderen Worten, eine Monade) eingesetzt werden können
   for Verständnis statt ns. Ein gutes Beispiel
   ist die Option-Monade. Hier ist das Vorherige Beispiel
   wo die gleichen for - Anweisung funktioniert sowohl auf der
   List sowie Option Monaden:

   //(1)
   val result = 
     for { 
       i <- ns          //ns is a List monad
       i2 <- Some(i*i)  //Some(i*i) is Option
         if i2 % 2 == 0 //filter
     } yield i2
   
   //Slightly more contrived example:
   def evenSqr(n: Int) = { //return the square of a number 
     val sqr = n*n         //only when the square is even
     if (sqr % 2 == 0) Some (sqr)
     else None
   }
   
   //(2)
   result = 
     for { 
       i <- ns  
       i2 <- evenSqr(i) //i2 may/maynot be defined for i!
     } yield i2

   Im letzten Beispiel, die transformation würde sich vielleicht freuen
   wie diese:

   //1st example
   val result = 
     ns.flatMap(i => Some(i*i)).filter(i2 => i2 %2 ==0)
   
   //Or for the 2nd example
   result = 
     ns.flatMap(i => evenSqr(i)) 

   In Slick, Abfragen monadischen - Sie sind nur Objekte mit
   die map, flatMap und filter Methoden. Also die for Verständnis
   (siehe die Erklärung der * Methode) einfach übersetzt:

   val q = 
     Query(Bars).filter(b => b.id === 42).map(b => b.name ~ 1)
   //Type of q is Query[(String, Int)]
   
   val r: List[(String, Int)] = q.list //Actually run the query

   Wie Sie sehen können, flatMapmap und filter werden verwendet, um
   generieren Sie eine Query durch die wiederholte transformation von Query(Bars)
   mit jedem Aufruf von filter und map. Im Fall von
   Sammlungen diese Methoden tatsächlich Durchlaufen und filtern Sie die Sammlung
   aber Glatt sind Sie zum generieren von SQL. Mehr Informationen finden Sie hier:
   Wie funktioniert Scala Slick übersetzen Scala-code in JDBC?

InformationsquelleAutor der Antwort Faiz