scala slick requête valeur de retour

Je suis plutôt nouveau à la Scala et ont été aux prises avec slick et ne peut pas voir comment retourner les résultats d'une requête à l'appel de la méthode

J'ai un simple UserDto

case class UserDto(val firstName:String,
  val lastName:String,
  val userName:String,
  val isAdmin:Boolean) {}

un objet de table Utilisateur

object User extends Table[(String, String, String, Boolean)]("USER") {

  def firstName = column[String]("FIRST_NAME")
  def lastName = column[String]("LAST_NAME")
  def userName = column[String]("USER_NAME")
  def admin = column[Boolean]("IS_ADMIN")

  def * = firstName ~ lastName ~ userName ~ admin

}

et une classe de requête

class UserQuerySlickImpl(dataSource:DataSource) {

  def getResults(userName:String):Option[UserDto] = {
    var resultDto:Option[UserDto] = None

    Database.forDataSource(dataSource) withSession {
      val q = for {u <- User if u.userName is userName}
      yield (u.firstName, u.lastName, u.userName, u.admin)

      for (t <- q) {
        t match {
          case (f:String, l:String, u:String, a:Boolean) => 
            resultDto = Some(new UserDto(f, l, u, a))
        }
      }
    }
    resultDto
  }
}

Je peux interroger la base de données et un utilisateur qui correspond au nom d'utilisateur, mais la seule façon que je pouvais comprendre comment retourner que l'utilisateur est par la création d'une var à l'extérieur de la Database.forDataSource....{}.

Est-il une meilleure façon de ne pas utiliser le var, mais renvoie la resultDto directement.

aussi est-il un moyen de construire la UserDto directement à partir de la première, pour la compréhension plutôt que d'avoir besoin de la deuxième (t <- q) ...

Je suis en utilisant slick_2.10.0-M7, version 0.11.1.

source d'informationauteur Doug Anderson

scala slick

9

Votre q est une question, pas une liste de résultats. La présence de foreach peut-être un peu de confusion à cet égard, mais pour obtenir une List de résultats, vous devez faire q.list premier. Qui vous donne des méthodes comme map et foldLeft et ainsi de suite.

Si vous voulez obtenir un seul/le premier résultat dans un Optionutilisez q.firstOption. Une fois que vous avez cela, vous pouvez map votre fonction le 'Option [(...)]" pour transformer le tuple souhaité DTO.

Une autre façon serait de spécifier une mise en correspondance personnalisée qui mappe automatiquement votre résultat de n-uplets de certains cas de la classe à l'aide de la <> opérateur, voir http://slick.typesafe.com/doc/0.11.2/lifted-embedding.html#tables:
```
case class User(id: Option[Int], first: String, last: String) 

object Users extends Table[User]("users") {
  def id = column[Int]("id", O.PrimaryKey, O.AutoInc)
  def first = column[String]("first")
  def last = column[String]("last")
  def * = id.? ~ first ~ last <> (User, User.unapply _)
}
```

Je n'ai pas joué avec Slick encore, mais si c'est raisonnable, je veux dire compatible avec Scala conventions de), vous devez être en mesure de faire quelque chose comme

def getResults(userName:String):Option[UserDto] =
  Database.forDataSource(dataSource) withSession {
    val q = for {u <- User if u.userName is userName}
      yield (u.firstName, u.lastName, u.userName, u.admin)

    q.firstOption map { case (f, l, u, a) => UserDto(f, l, u, a) }
  }

C'est exactement ce que vous feriez si q était un List[(String, String, String, Boolean)].

Nettoyer un peu, vous pouvez écrire

def getResults(userName:String):Option[UserDto] =
  Database.forDataSource(dataSource) withSession {
    (for (u <- User if u.userName is userName)
      yield UserDto(u.firstName, u.lastName, u.userName, u.admin)).firstOption
  }

Sinon, vous devriez être en mesure d'utiliser

q foreach { 
   case (f, l, u, a) => return Some(UserDto(f, l, u, a))
}
return None

Généralement, return des énoncés comme celui-ci devrait être évitée, alors j'espère que q's type vous donne quelque chose de plus fonctionnel pour travailler avec.

Vous devez vous connecter pour publier un commentaire.