È possibile utilizzare la clausola IN in plain sql Slick per numeri interi?

Question

C'è una domanda simile qui ma in realtà non risponde alla domanda.

Is it possible to use IN clause in plain sql Slick?

Si noti che questo è in realtà parte di una query più grande e più complessa, quindi ho bisogno di usare SQL normale invece di slick di sollevato incorporamento. Qualcosa come la seguente sarà buono:

val ids = List(2,4,9) 
sql"SELECT * FROM coffee WHERE id IN ($ids)" 

Answer 1

Il prefisso sql sblocca un StringContext in cui è possibile impostare i parametri SQL. Non esiste un parametro SQL per un elenco, quindi puoi facilmente finire per aprirti all'iniezione SQL qui se non stai attento. Ci sono alcuni buoni (e alcuni pericolosi) suggerimenti su come gestire questo problema con SQLServer su this question. Hai un paio di opzioni:

La cosa migliore è probabilmente quello di utilizzare l'operatore #$ insieme mkString interpolare SQL dinamico:

val sql = sql"""SELECT * FROM coffee WHERE id IN (#${ids.mkString(",")})""" 

Questo non usa correttamente i parametri e quindi potrebbe essere aperto a sql- iniezione e altri problemi.

Un'altra opzione è quella di utilizzare regolare l'interpolazione di stringa e mkString per creare l'istruzione:

val query = s"""SELECT * FROM coffee WHERE id IN (${ids.mkString(",")})""" 
StaticQuery.queryNA[Coffee](query) 

Questo è essenzialmente lo stesso approccio utilizzando #$, ma potrebbe essere più flessibili nel caso generale.

Se la vulnerabilità di SQL-injection è una delle principali preoccupazioni (ad esempio se gli elementi di ids sono forniti dall'utente), è possibile creare una query con un parametro per ciascun elemento di ids. Allora è necessario fornire un campione personalizzato SetParameter in modo che chiazza di petrolio può trasformare il List in parametri:

implicit val setStringListParameter = new SetParameter[List[String]]{ 
    def apply(v1: List[String], v2: PositionedParameters): Unit = { 
     v1.foreach(v2.setString) 
    } 
} 

val idsInClause = List.fill(ids.length)("?").mkString("(", ",", ")") 
val query = s"""SELECT * FROM coffee WHERE id IN ($idsInClause)""" 
Q.query[List[String], String](query).apply(ids).list(s) 

Dal momento che il ids sono Ints, questo è probabilmente meno di una preoccupazione, ma se si preferisce questo metodo, avrebbe solo bisogno di cambiare il setStringListParameter di utilizzare Int invece di String:

Answer 2

val ids = List(610113193610210035L, 220702198208189710L) 

    implicit object SetListLong extends SetParameter[List[Long]] { 
    def apply(vList: List[Long], pp: PositionedParameters) { 
     vList.foreach(pp.setLong) 
    } 
    } 

    val select = sql""" 
     select idnum from idnum_0 
     where idnum in ($ids#${",?" * (ids.size - 1)}) 
    """.as[Long] 

@ Ben Reich è giusto. questo è un altro codice di esempio, test su slick 3.1.0.

($ids#${",?" * (ids.size - 1)})

Answer 3

Anche se questo non è la risposta universale, e non può essere quello che l'autore ha voluto, ho ancora voglia di farlo notare a chi considera questa domanda.

Alcuni backend DB supportano tipi di array e sono presenti estensioni a Slick che consentono di impostare questi tipi di array nelle interpolazioni.

Per esempio, Postgres ha la sintassi where column = any(array), e con slick-pg è possibile utilizzare questa sintassi in questo modo:

def query(ids: Seq[Long]) = db.run(sql"select * from table where ids = any($ids)".as[Long]) 

Questo porta una sintassi molto più pulito, che è più amichevole per la cache dichiarazione compilatore e anche al sicuro da Iniezioni SQL e rischio generale di creare un SQL non valido con la sintassi di interpolazione #$var.