Zręczny 2 - Zaktualizuj kolumny w tabeli i zwróć obiekt całej tabeli

Question

Jak zaktualizować kilka kolumn w tabeli tabeli, zwracając całą zaktualizowaną tabelę przy użyciu śliskiego?

Zakładając SomeTables pewne TableQuery, byś zazwyczaj napisać kwerendę tak, jeśli chcesz na przykład dodać element do tabeli (i powrót do nowo dodanego elementu)

val returnedItem = SomeTables returning SomeTables += someTable 

Jak byś zrobić to samo, jeśli chcesz zaktualizować pozycję i powrócić całość z powrotem cały element, podejrzewam byś zrobił coś takiego

val q = SomeTables.filter(_.id === id).map(x => (x.someColumn,x.anotherColumn)) returning SomeTables 
val returnedItem = q.update((3,"test")) 

Poniższy kod jednak nie działa, a ja nie widzę żadnej dokumentacji o tym, jak to zrobić jest

Zauważ, że jestem świadomy można tylko kwerendy elementu wcześniej, zaktualizuj je, a następnie za pomocą kopii na oryginalny obiekt, jednak wymaga to dużo boilerplate (i DB wycieczki również)

Answer 1

Ta funkcja nie jest obsługiwane w środowisku Slick (v2 lub v3-M1); chociaż nie widzę żadnego konkretnego powodu, który zabraniałby implementacji, UPDATE ... RETURNING nie jest standardową funkcją SQL (na przykład H2 nie obsługuje go: http://www.h2database.com/html/grammar.html#update). Opuszczę jako ćwiczenie dla czytelnika, aby zbadać, w jaki sposób można bezpiecznie i efektywnie emulować funkcję dla RDBMS z brakiem UDPATE ... RETURNING.

Po wywołaniu "powrocie" na scala.slick.lifted.Query, daje on JdbcInsertInvokerComponent$ReturningInsertInvokerDef. Nie znajdziesz metody update, mimo że istnieje metoda ; jednakże insertOrUpdate zwraca tylko wynik wyrażenia returning, jeśli wystąpi wstawka, zwracana jest None w celu aktualizacji, więc nie ma tutaj pomocy.

Z tego możemy wywnioskować, że jeśli chcesz korzystać z funkcji SQL UPDATE ... RETURNING, musisz albo użyć StaticQuery, albo rozwinąć własną poprawkę do wersji Slick. Można ręcznie napisać zapytania (i ponownie wdrożyć swoje projekcje tabelę jako getResult/SetParameter serializers), można też spróbować tego fragmentu kodu:

package com.spingo.slick 

import scala.slick.driver.JdbcDriver.simple.{queryToUpdateInvoker, Query} 
import scala.slick.driver.JdbcDriver.{updateCompiler, queryCompiler, quoteIdentifier} 
import scala.slick.jdbc.{ResultConverter, CompiledMapping, JdbcBackend, JdbcResultConverterDomain, GetResult, SetParameter, StaticQuery => Q} 
import scala.slick.util.SQLBuilder 
import slick.ast._ 

object UpdateReturning { 
    implicit class UpdateReturningInvoker[E, U, C[_]](updateQuery: Query[E, U, C]) { 
    def updateReturning[A, F](returningQuery: Query[A, F, C], v: U)(implicit session: JdbcBackend#Session): List[F] = { 
     val ResultSetMapping(_, 
     CompiledStatement(_, sres: SQLBuilder.Result, _), 
     CompiledMapping(_updateConverter, _)) = updateCompiler.run(updateQuery.toNode).tree 

     val returningNode = returningQuery.toNode 
     val fieldNames = returningNode match { 
     case Bind(_, _, Pure(Select(_, col), _)) => 
      List(col.name) 
     case Bind(_, _, Pure(ProductNode(children), _)) => 
      children map { case Select(_, col) => col.name } toList 
     case Bind(_, TableExpansion(_, _, TypeMapping(ProductNode(children), _, _)), Pure(Ref(_), _)) => 
      children map { case Select(_, col) => col.name } toList 
     } 

     implicit val pconv: SetParameter[U] = { 
     val ResultSetMapping(_, compiled, CompiledMapping(_converter, _)) = updateCompiler.run(updateQuery.toNode).tree 
     val converter = _converter.asInstanceOf[ResultConverter[JdbcResultConverterDomain, U]] 
     SetParameter[U] { (value, params) => 
      converter.set(value, params.ps) 
     } 
     } 

     implicit val rconv: GetResult[F] = { 
     val ResultSetMapping(_, compiled, CompiledMapping(_converter, _)) = queryCompiler.run(returningNode).tree 
     val converter = _converter.asInstanceOf[ResultConverter[JdbcResultConverterDomain, F]] 
     GetResult[F] { p => converter.read(p.rs) } 
     } 

     val fieldsExp = fieldNames map (quoteIdentifier) mkString ", " 
     val sql = sres.sql + s" RETURNING ${fieldsExp}" 
     val unboundQuery = Q.query[U, F](sql) 
     unboundQuery(v).list 
    } 
    } 
} 

Jestem pewien powyższego można poprawić; Napisałem to na podstawie mojej nieco ograniczonej wiedzy na temat wewnętrznych wersji oprogramowania Slick i działa ono dla mnie i może wykorzystywać predykcje/odwzorowania typów, które już zdefiniowałeś.

Zastosowanie:

import com.spingo.slick.UpdateReturning._ 
val tq = TableQuery[MyTable] 
val st = tq filter(_.id === 1048003) map { e => (e.id, e.costDescription) } 
st.updateReturning(tq map (identity), (1048003, Some("such cost")))