Come utilizzare ScalaQuery per inserire un campo BLOB?

Question

Ho usato ScalaQuery e Scala.

Se si dispone di un oggetto [Byte] array, come si inserisce nella tabella?

object TestTable extends BasicTable[Test]("test") { 
    def id = column[Long]("mid", O.NotNull) 
    def extInfo = column[Blob]("mbody", O.Nullable) 

    def * = id ~ extInfo <> (Test, Test.unapply _) 
} 

case class Test(id: Long, extInfo: Blob) 

posso definire il metodo utilizzato def extInfo = column[Array[Byte]]("mbody", O.Nullable), come operare (UPDATE, INSERT, SELECT) con il campo di tipo BLOB?

BTW: nessun tag ScalaQuery

Answer 1

Dal momento che il campo BLOB è annullabile, suggerisco cambiando il suo tipo Scala di opzione [Blob], per la seguente definizione:

object TestTable extends Table[Test]("test") { 
    def id = column[Long]("mid") 
    def extInfo = column[Option[Blob]]("mbody") 
    def * = id ~ extInfo <> (Test, Test.unapply _) 
} 

case class Test(id: Long, extInfo: Option[Blob]) 

è possibile utilizzare un grezzo, valore Blob nullable, se si preferisce, ma poi è necessario utilizzare orElse (null) sulla colonna per ottenere effettivamente un valore nullo fuori di esso (invece di lanciare un'eccezione):

 def * = id ~ extInfo.orElse(null) <> (Test, Test.unapply _) 

Ora per l'una gestione del BLOC ctual. La lettura è straight-forward: Si ottiene solo un oggetto Blob nel risultato che viene realizzato tramite il driver JDBC, ad es .:

Query(TestTable) foreach { t => 
    println("mid=" + t.id + ", mbody = " + 
     Option(t.extInfo).map { b => b.getBytes(1, b.length.toInt).mkString }) 
    } 

Se si desidera inserire o aggiornare i dati, è necessario creare i propri BLOB. Un'implementazione adatto per un oggetto Blob stand-alone è fornita da funzionalità RowSet di JDBC:

import javax.sql.rowset.serial.SerialBlob 

TestTable insert Test(1, null) 
TestTable insert Test(2, new SerialBlob(Array[Byte](1,2,3))) 

Edit: Ed ecco un TypeMapper [Array [Byte]] per Postgres (i cui i BLOB non sono ancora supportati da ScalaQuery):

implicit object PostgresByteArrayTypeMapper extends 
     BaseTypeMapper[Array[Byte]] with TypeMapperDelegate[Array[Byte]] { 
    def apply(p: BasicProfile) = this 
    val zero = new Array[Byte](0) 
    val sqlType = java.sql.Types.BLOB 
    override val sqlTypeName = "BYTEA" 
    def setValue(v: Array[Byte], p: PositionedParameters) { 
     p.pos += 1 
     p.ps.setBytes(p.pos, v) 
    } 
    def setOption(v: Option[Array[Byte]], p: PositionedParameters) { 
     p.pos += 1 
     if(v eq None) p.ps.setBytes(p.pos, null) else p.ps.setBytes(p.pos, v.get) 
    } 
    def nextValue(r: PositionedResult) = { 
     r.pos += 1 
     r.rs.getBytes(r.pos) 
    } 
    def updateValue(v: Array[Byte], r: PositionedResult) { 
     r.pos += 1 
     r.rs.updateBytes(r.pos, v) 
    } 
    override def valueToSQLLiteral(value: Array[Byte]) = 
     throw new SQueryException("Cannot convert BYTEA to literal") 
    } 

Answer 2

ho appena inviare un codice aggiornato per Scala e SQ, forse sarà risparmiare un po 'di tempo per qualcuno:

object PostgresByteArrayTypeMapper extends 
    BaseTypeMapper[Array[Byte]] with TypeMapperDelegate[Array[Byte]] { 
    def apply(p: org.scalaquery.ql.basic.BasicProfile) = this 
    val zero = new Array[Byte](0) 
    val sqlType = java.sql.Types.BLOB 
    override val sqlTypeName = "BYTEA" 
    def setValue(v: Array[Byte], p: PositionedParameters) { 
    p.pos += 1 
    p.ps.setBytes(p.pos, v) 
    } 
    def setOption(v: Option[Array[Byte]], p: PositionedParameters) { 
    p.pos += 1 
    if(v eq None) p.ps.setBytes(p.pos, null) else p.ps.setBytes(p.pos, v.get) 
    } 
    def nextValue(r: PositionedResult) = { 
    r.nextBytes() 
    } 
    def updateValue(v: Array[Byte], r: PositionedResult) { 
    r.updateBytes(v) 
    } 
    override def valueToSQLLiteral(value: Array[Byte]) = 
    throw new org.scalaquery.SQueryException("Cannot convert BYTEA to literal") 

} 

e poi l'utilizzo, ad esempio:

... 
// defining a column 
def content = column[Array[Byte]]("page_Content")(PostgresByteArrayTypeMapper)