如何调用存储过程并在Slick中获取返回值（使用Scala）
我试图从Slick 3.0（在Play Framework中）调用存储过程。 我一直在重复这些文档，但不幸的是，Typesafe中的普通SQL文档从不显示调用存储过程。
看起来非常直截了当的是造成一个通常模糊的Scala错误信息：
val f = Try {
val call: DBIO[Int] = sqlu"?=call app_glimpulse_invitation_pkg.n_send_invitation(${i.token}, ${i.recipientAccountId.getOrElse(None)}, ${i.email}, ${i.phoneNumber}, ${requestType})"
val result: Future[Int] = db.run(call)
val r = Await.result(result, Duration.Inf) // should only return one; use .seq.count(_.id != null)) to validate
val z = result.value.get.get // should return the stored procedure return value...?
}
上面的代码导致这个编译器错误：
[error] /Users/zbeckman/Projects/Glimpulse/Server-2/project/glimpulse-server/app/controllers/GPInviteService/GPInviteService.scala:120: could not find implicit value for parameter e: slick.jdbc.SetParameter[Product with Serializable]
[error] val call: DBIO[Int] = sqlu"?=call app_glimpulse_invitation_pkg.n_send_invitation(${i.token}, ${i.recipientAccountId.getOrElse(None)}, ${i.email}, ${i.phoneNumber}, ${requestType})"
[error] ^
如果我使用纯硬编码的调用语句（删除所有${i.xyz}引用，我可以编译它...但是，然后，我得到一个运行时错误，报告Update statements should not return a result set.
这导致我将语句更改为常规的sql调用：
val call: DBIO[Seq[(Int)]] = sql"call app_glimpulse_invitation_pkg.n_send_invitation('xyz', 1000, 1, 'me@here.com', NULL, 'I', ${out})".as[(Int)]
val result: Future[Int] = db.run(call)
但是这也导致了一个编译错误：
[error] /Users/zbeckman/Projects/Glimpulse/Server-2/project/glimpulse-server/app/controllers/GPInviteService/GPInviteService.scala:126: type mismatch;
[error] found : slick.driver.PostgresDriver.api.DBIO[Seq[Int]]
[error] (which expands to) slick.dbio.DBIOAction[Seq[Int],slick.dbio.NoStream,slick.dbio.Effect.All]
[error] required: slick.dbio.DBIOAction[Int,slick.dbio.NoStream,Nothing]
[error] val result: Future[Int] = db.run(call)
[error] ^
我确实发现（当浏览Slick API时）会话上的prepareCall ，但是再次......没有关于如何使用这个东西的文档。
任何和所有的建议将非常感激。 这对我来说已经成为一个巨大的阻碍因素，因为我们确实需要对我们的Postgres存储过程进行一次工作调用。 谢谢。
那么，在对相互矛盾的文档进行了大量研究和回顾之后，我找到了答案。 不幸的是，这不是我正在寻找的那个：
对于返回完整表或存储过程的数据库函数，请使用纯SQL查询。 当前不支持返回多个结果集的存储过程。
底线，Slick不支持开箱即用的存储功能或程序，所以我们必须编写自己的。
答案是通过抓取会话对象从Slick中退出，然后使用标准JDBC来管理过程调用。 对于那些熟悉JDBC的人来说，这并不是一件快乐的事......但幸运的是，在Scala中，我们可以通过模式匹配来做一些相当不错的技巧，从而使工作更轻松。
我的第一步是整合一个干净的外部API。 这就是它最终的样子：
val db = Database.forDataSource(DB.getDataSource)
var response: Option[GPInviteResponse] = None
db.withSession {
implicit session => {
val parameters = GPProcedureParameterSet(
GPOut(Types.INTEGER) ::
GPIn(Option(i.token), Types.VARCHAR) ::
GPIn(recipientAccountId, Types.INTEGER) ::
GPIn(Option(contactType), Types.INTEGER) ::
GPIn(contactValue, Types.VARCHAR) ::
GPIn(None, Types.INTEGER) ::
GPIn(Option(requestType), Types.CHAR) ::
GPOut(Types.INTEGER) ::
Nil
)
val result = execute(session.conn, GPProcedure.SendInvitation, parameters)
val rc = result.head.asInstanceOf[Int]
Logger(s"FUNC return code: $rc")
response = rc match {
case 0 => Option(GPInviteResponse(true, None, None))
case _ => Option(GPInviteResponse(false, None, Option(GPError.errorForCode(rc))))
}
}
}
db.close()
这是一个快速演练：我创建了一个简单的容器来模拟存储过程调用。 GPProcedureParameterSet可以包含GPIn，GPOut或GPInOut实例的列表。 这些中的每一个都将一个值映射到JDBC类型。 容器看起来像这样：
case class GPOut(parameterType: Int) extends GPProcedureParameter
object GPOut
case class GPIn(value: Option[Any], parameterType: Int) extends GPProcedureParameter
object GPIn
case class GPInOut(value: Option[Any], parameterType: Int) extends GPProcedureParameter
object GPInOut
case class GPProcedureParameterSet(parameters: List[GPProcedureParameter])
object GPProcedureParameterSet
object GPProcedure extends Enumeration {
type GPProcedure = Value
val SendInvitation = Value("{?=call app_glimpulse_invitation_pkg.n_send_invitation(?, ?, ?, ?, ?, ?, ?)}")
}
为了完整起见，我将GPProcedure列举包括进来，以便将它们放在一起。
所有这些都交给我的execute()函数。 它大而且讨厌，闻起来像老式的JDBC，我相信我会相当多地改进Scala。 我在昨晚凌晨3点完成了这个工作，但是它工作起来，而且工作得很好。 请注意，这个特定的execute()函数返回一个包含所有OUT参数的List ...我必须编写一个单独的executeQuery()函数来处理返回resultSet的过程。 （但是这个区别并不重要：您只需编写一个循环来抓取resultSet.next并将其全部填充到List或您想要的其他任何结构中）。
以下是令人讨厌的Scala < - > JDBC映射execute()函数：
def execute(connection: Connection, procedure: GPProcedure, ps: GPProcedureParameterSet) = {
val cs = connection.prepareCall(procedure.toString)
var index = 0
for (parameter <- ps.parameters) {
index = index + 1
parameter match {
// Handle any IN (or INOUT) types: If the optional value is None, set it to NULL, otherwise, map it according to
// the actual object value and type encoding:
case p: GPOut => cs.registerOutParameter(index, p.parameterType)
case GPIn(None, t) => cs.setNull(index, t)
case GPIn(v: Some[_], Types.NUMERIC | Types.DECIMAL) => cs.setBigDecimal(index, v.get.asInstanceOf[java.math.BigDecimal])
case GPIn(v: Some[_], Types.BIGINT) => cs.setLong(index, v.get.asInstanceOf[Long])
case GPIn(v: Some[_], Types.INTEGER) => cs.setInt(index, v.get.asInstanceOf[Int])
case GPIn(v: Some[_], Types.VARCHAR | Types.LONGVARCHAR) => cs.setString(index, v.get.asInstanceOf[String])
case GPIn(v: Some[_], Types.CHAR) => cs.setString(index, v.get.asInstanceOf[String].head.toString)
case GPInOut(None, t) => cs.setNull(index, t)
// Now handle all of the OUT (or INOUT) parameters, these we just need to set the return value type:
case GPInOut(v: Some[_], Types.NUMERIC) => {
cs.setBigDecimal(index, v.get.asInstanceOf[java.math.BigDecimal]); cs.registerOutParameter(index, Types.NUMERIC)
}
case GPInOut(v: Some[_], Types.DECIMAL) => {
cs.setBigDecimal(index, v.get.asInstanceOf[java.math.BigDecimal]); cs.registerOutParameter(index, Types.DECIMAL)
}
case GPInOut(v: Some[_], Types.BIGINT) => {
cs.setLong(index, v.get.asInstanceOf[Long]); cs.registerOutParameter(index, Types.BIGINT)
}
case GPInOut(v: Some[_], Types.INTEGER) => {
cs.setInt(index, v.get.asInstanceOf[Int]); cs.registerOutParameter(index, Types.INTEGER)
}
case GPInOut(v: Some[_], Types.VARCHAR) => {
cs.setString(index, v.get.asInstanceOf[String]); cs.registerOutParameter(index, Types.VARCHAR)
}
case GPInOut(v: Some[_], Types.LONGVARCHAR) => {
cs.setString(index, v.get.asInstanceOf[String]); cs.registerOutParameter(index, Types.LONGVARCHAR)
}
case GPInOut(v: Some[_], Types.CHAR) => {
cs.setString(index, v.get.asInstanceOf[String].head.toString); cs.registerOutParameter(index, Types.CHAR)
}
case _ => { Logger(s"Failed to match GPProcedureParameter in executeFunction (IN): index $index (${parameter.toString})") }
}
}
cs.execute()
// Now, step through each of the parameters, and get the corresponding result from the execute statement. If there is
// no result for the specified column (index), we'll basically end up getting a "nothing" back, which we strip out.
index = 0
val results: List[Any] = for (parameter <- ps.parameters) yield {
index = index + 1
parameter match {
case GPOut(Types.NUMERIC) | GPOut(Types.DECIMAL) => cs.getBigDecimal(index)
case GPOut(Types.BIGINT) => cs.getLong(index)
case GPOut(Types.INTEGER) => cs.getInt(index)
case GPOut(Types.VARCHAR | Types.LONGVARCHAR | Types.CHAR) => cs.getString(index)
case GPInOut(v: Some[_], Types.NUMERIC | Types.DECIMAL) => cs.getInt(index)
case GPInOut(v: Some[_], Types.BIGINT) => cs.getLong(index)
case GPInOut(v: Some[_], Types.INTEGER) => cs.getInt(index)
case GPInOut(v: Some[_], Types.VARCHAR | Types.LONGVARCHAR | Types.CHAR) => cs.getString(index)
case _ => {
Logger(s"Failed to match GPProcedureParameter in executeFunction (OUT): index $index (${parameter.toString})")
}
}
}
cs.close()
// Return the function return parameters (there should always be one, the caller will get a List with as many return
// parameters as we receive):
results.filter(_ != (()))
}
上一篇: How to call a stored procedure and get return value in Slick (using Scala)