油滑：与作为参数的列LIKE查询

Question

我有以下SQL查询，我想但是类似符号不为字符串定义为映射到油滑

SELECT * FROM rates 
WHERE '3113212512' LIKE (prefix || '%') and present = true 
ORDER BY prefix DESC 
LIMIT 1; 

其中：

case class Rate(grid: String, prefix: String, present: Boolean) 

class Rates(tag: Tag) extends Table[Rate](tag, "rates") { 
    def grid = column[String]("grid", O.PrimaryKey, O.NotNull) 
    def prefix = column[String]("prefix", O.NotNull) 
    def present = column[Boolean]("present", O.NotNull) 

    // Foreign keys 
    def ratePlan = foreignKey("rate_plan_fk", ratePlanId, RatePlans)(_.grid) 
    def ratePlanId = column[String]("rate_plan_id", O.NotNull) 

    def * = (grid, prefix, present) <>(Rate.tupled, Rate.unapply) 
} 

object Rates extends TableQuery(new Rates(_)) { 
    def findActiveRateByRatePlanAndPartialPrefix(ratePlan: String, prefix: String) = { 
    DB withSession { 
     implicit session: Session => 
     Rates.filter(_.ratePlanId === ratePlan) 
      .filter(_.present === true) 
      .filter(prefix like _.prefix) 
      .sortBy(_.prefix.desc).firstOption 
    } 
    } 
} 

显然，这是合乎逻辑的，这样的事情是行不通的：

.filter(prefix like _.prefix) 

和：

.filter(_.prefix like prefix) 

将呈现不正确的SQL，而我还没有考虑到 '％' 现在（仅在关于前缀子句：

(x2."prefix" like '3113212512') 

相反的：

'3113212512' LIKE (prefix || '%') 

中当然我可以使用静态查询来解决这个问题，但我想知道这是否可能？

为了清楚起见，这里是数据库中的某些前缀

31 
3113 
312532623 
31113212 

和31113212预期结果

Answer 1

您可以简单地以支持的样式重写您的查询。我想这应该是等价的：

.filter(s => (s.prefix === "") || s.prefix.isEmpty || LiteralColumn(prefix) like s.prefix) 

如果条件更加复杂，你需要一个CASE表达式，见http://slick.typesafe.com/doc/2.1.0/sql-to-slick.html#case

如果你还是想||运营商则可以将其定义是这样的：

/** SQL || for String (currently collides with Column[Boolean] || so other name) */ 
val thisOrThat = SimpleBinaryOperator[String]("||") 

...

.filter(s => LiteralColumn(prefix) like thisOrThat(s.prefix,"%")) 

我没有尝试这个，虽然我看到我们没有对SimpleBinaryOperator测试。如果不起作用，请在github.com/slick/slick上打开一张票。也许我们也应该改变它来返回一个类型化的函数。我为那个https://github.com/slick/slick/issues/1073添加了一张票。

另见http://slick.typesafe.com/doc/2.1.0/userdefined.html#scalar-database-functions

幸运的是SimpleBinaryOperator甚至没有在这里需要。

Answer 2

更新2

一个实际上并不需要的CONCAT，因为它可写成如下：

filter(s => LiteralColumn(prefix) like (s.prefix ++ "%")) 

UPDATE：

后cvogt暗示这是不使用内部油滑的API最终结果：

 val concat = SimpleBinaryOperator[String]("||") 

     Rates.filter(_.ratePlanId === ratePlan) 
      .filter(_.present === true) 
      .filter(s => LiteralColumn(prefix) like concat(s.prefix, "%")) 
      .sortBy(_.prefix.desc).firstOption 

这完全得：

and ('3113212512' like (x2."prefix" || '%')) 

备选：

这似乎是可能的。但请注意，以下方法使用Slick的内部API，并且可能由于API更改而不兼容（请参阅cvogt的评论）我使用Slick 2.1.0。

基本上我创建了一个扩展油滑中，我定义一个定制方案来实现所需的结果：

import utils.Helpers._ 

[...] 

    def findActiveRateByRatePlanAndPartialPrefix(ratePlan: String, prefix: String) = { 
    DB withSession { 
     implicit session: Session => 
     Rates.filter(_.ratePlanId === ratePlan) 
      .filter(_.present === true) 
      .filter(_.prefix subPrefixFor prefix) 
      .sortBy(_.prefix.desc).firstOption 
    } 
    } 

而且会使正确的：

package utils 

import scala.language.{higherKinds, implicitConversions} 
import scala.slick.ast.ScalaBaseType._ 
import scala.slick.ast._ 
import scala.slick.lifted.{Column, ExtensionMethods} 

object Helpers { 
    implicit class PrefixExtensionMethods[P1](val c: scala.slick.lifted.Column[P1]) extends AnyVal with ExtensionMethods[String, P1] { 
    def subPrefixFor[P2, R](prefix: Column[P2])(implicit om: o#arg[String, P2]#to[Boolean, R]) = { 
     om.column(Library.Like, prefix.toNode, om.column(new Library.SqlOperator("||"), n, LiteralNode("%")).toNode) 
    } 
    } 
} 

如下这现在可以使用结果：

and ('3113212512' like (x2."prefix" || '%')) 

备注：

1. 我大概可以有一些更好的命名
2. 只好链||和使用om.column
3. 我引入了新的SqlOperator，因为Or运算符呈现或者我需要在Postgres中连接||