¿Cómo usar ScalaQuery para insertar un campo BLOB?

Question

Usé ScalaQuery y Scala.

Si tengo un objeto Array [Byte], ¿cómo lo inserto en la tabla?

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) 

¿Puedo definir el método utilizado def extInfo = column[Array[Byte]]("mbody", O.Nullable), cómo operar (UPDATE, INSERT, SELECT) con el campo tipo BLOB?

Por cierto: ninguna etiqueta ScalaQuery

Answer 1

Puesto que el campo BLOB es anulable, sugiero cambiando su tipo Scala a la opción [Blob], por la siguiente definición:

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]) 

Se puede utilizar una prima, Blob valor anulable si lo prefiere, pero entonces es necesario utilizar orElse (nulo) en la columna para hacer que un valor nulo fuera de él (en lugar de lanzar una excepción):

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

Ahora para la una manejo de BLOB ctual. La lectura es directa: Usted acaba de obtener un objeto Blob en el resultado que se realiza mediante el controlador JDBC, por ejemplo .:

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

Si desea insertar o actualizar datos, tiene que crear sus propios BLOB. Una aplicación adecuada para un objeto Blob independiente es proporcionada por función RowSet de JDBC:

import javax.sql.rowset.serial.SerialBlob 

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

Editar: Y aquí hay una TypeMapper [Matriz [Byte]] para Postgres (cuyo BLOB sin embargo, no son compatibles con 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

acabo de publicar un código actualizado para la Scala y SQ, tal vez va a ahorrar algo de tiempo para alguien:

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") 

} 

y después del uso, por ejemplo:

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