Scala de la nappe de la requête d'origine dans la liste

J'essaie d'apprendre à utiliser Slick pour la requête MySQL. J'ai ce type de requête de travail pour obtenir une Visite unique objet:

Q.query[(Int,Int), Visit]("""
    select * from visit where vistor = ? and location_code = ?
""").firstOption(visitorId,locationCode)

Ce que je voudrais savoir c'est comment puis-je changer la au-dessus de requête pour obtenir une Liste[Visitez] pour une collection de Lieux...quelque chose comme ceci:

val locationCodes = List("loc1","loc2","loc3"...)
Q.query[(Int,Int,List[String]), Visit]("""
    select * from visit where vistor = ? and location_code in (?,?,?...)
""").list(visitorId,locationCodes)

Est-ce possible avec Slick?

N'est-ce pas le travail? Devrait fonctionner.
Ne pouvez pas vous en tenir à des n-Uplets de valeurs? Il permettrait de garantir que le nombre de paramètres que vous passez à la requête est fixe.

InformationsquelleAutor ShatyUT | 2012-12-28

29

Que les autres de répondre à l'indique, c'est lourd à faire avec statique des requêtes. La statique de la requête de l'interface vous demande de décrire l'lier des paramètres comme Product. (Int, Int, String*)
n'est pas valide scala, et à l'aide de (Int,Int,List[String]) besoin de quelques kludges ainsi. En outre, l'obligation de s'assurer que locationCodes.size est toujours égal au nombre de (?, ?...) que vous avez dans votre requête est fragile.

Dans la pratique, ce n'est pas trop un problème parce que vous voulez être à l'aide de la requête de l'errance de la place, qui est de type sécurisé et la méthode recommandée pour l'utilisation de la Nappe de.
```
val visitorId: Int = //whatever
val locationCodes = List("loc1","loc2","loc3"...)
//your query, with bind params.
val q = for {
    v <- Visits 
    if v.visitor is visitorId.bind
    if v.location_code inSetBind locationCodes
  } yield v
//have a look at the generated query.
println(q.selectStatement)
//run the query
q.list
```
C'est en supposant que vous avez votre place à des tables comme ceci:
```
case class Visitor(visitor: Int, ... location_code: String)

object Visitors extends Table[Visitor]("visitor") {
  def visitor = column[Int]("visitor")
  def location_code = column[String]("location_code")
  //.. etc
  def * = visitor ~ .. ~ location_code <> (Visitor, Visitor.unapply _)
}
```
Notez que vous pouvez toujours placer votre requête dans une méthode.
```
def byIdAndLocations(visitorId: Int, locationCodes: List[String]) = 
  for {
    v <- Visits 
    if v.visitor is visitorId.bind
    if v.location_code inSetBind locationCodes
  } yield v
}

byIdAndLocations(visitorId, List("loc1", "loc2", ..)) list
```
- Ça a l'air prometteur. Je ne suis pas de retour au travail jusqu'à mercredi mais je vais essayer de trouver un peu de temps pour tester cela avant et en fera rapport.
- Il est également possible d'utiliser la s.th. comme les Paramètres[List[Int]], puis remplacer le "def byIdAndLocations" avec un QueryTemplate "val byIdAndLocations" ?
- Ne pouvez-vous pas utiliser val ids = List(1,2,3) | val result: DBIO[Seq[T]] = query.filter(_.id inSet ids) par stackoverflow.com/questions/17408444/...?
InformationsquelleAutor Faiz
6

Cela ne fonctionne pas car le StaticQuery object (Q) prévoit implicitement définir les paramètres dans la chaîne de requête, en utilisant les paramètres de type de la query méthode pour créer une sorte de setter objet (de type scala.slick.jdbc.SetParameter[T]).

Le rôle de SetParameter[T] est de définir une requête paramètre une valeur de type T, où les types sont prises à partir de la query[...] des paramètres de type.

De ce que je vois il n'y a aucun objet défini pour T = List[A] pour un générique A, et il semble un choix judicieux, puisque vous ne pouvez pas écrire une requête sql avec une liste dynamique des paramètres pour la IN (?, ?, ?,...) clause

J'ai fait une expérience en fournissant une valeur implicite par le code suivant
```
import scala.slick.jdbc.{SetParameter, StaticQuery => Q}

def seqParam[A](implicit pconv: SetParameter[A]): SetParameter[Seq[A]] = SetParameter {  
    case (seq, pp) =>
        for (a <- seq) {
            pconv.apply(a, pp)
        }
}

implicit val listSP: SetParameter[List[String]] = seqParam[String]
```
avec cette portée, vous devriez être en mesure d'exécuter votre code
```
val locationCodes = List("loc1","loc2","loc3"...)
Q.query[(Int,Int,List[String]), Visit]("""
    select * from visit where vistor = ? and location_code in (?,?,?...)
""").list(visitorId,locationCodes)
```
Mais vous devez toujours manuellement garantir que locationCodes taille est la même que le nombre de ? dans votre IN clause

En fin de compte, je crois qu'un nettoyeur de solution de contournement peut être créé à l'aide de macros, de généraliser sur le type de séquence. Mais je ne suis pas sûr que ce serait un choix judicieux pour le cadre, étant donné les questions mentionnées ci-dessus avec la nature dynamique de la taille de la séquence.

InformationsquelleAutor pagoda_5b

Vous pouvez générer à la clause automatiquement comme ceci:

  def find(id: List[Long])(implicit options: QueryOptions) = {
    val in = ("?," * id.size).dropRight(1)
    Q.query[List[Long], FullCard](s"""
        select 
            o.id, o.name 
        from 
            organization o
        where
            o.id in ($in)
        limit
            ?
        offset
            ?
            """).list(id ::: options.limits)
  }

Et l'utilisation implicite SetParameter comme pagoda_5b dit

  def seqParam[A](implicit pconv: SetParameter[A]): SetParameter[Seq[A]] = SetParameter {
    case (seq, pp) =>
      for (a <- seq) {
        pconv.apply(a, pp)
      }
  }

  implicit def setLongList = seqParam[Long]

InformationsquelleAutor caiiiycuk

2

Si vous avez une requête complexe et la compréhension mentionnés ci-dessus n'est pas une option, vous pouvez faire quelque chose comme ce qui suit dans la Nappe de 3. Mais vous devez vous assurer de valider les données dans votre liste de paramètre de requête-vous pour empêcher l'injection SQL:
```
val locationCodes = "'" + List("loc1","loc2","loc3").mkString("','") + "'"
sql"""
  select * from visit where visitor = $visitor 
    and location_code in (#$locationCodes)
"""
```
Le # devant la variable de référence désactive le type de validation et permet de résoudre ce sans fournir une fonction pour la conversion implicite de la liste des paramètres de la requête.

InformationsquelleAutor markus

Vous devez vous connecter pour publier un commentaire.