如果 Slick 3.0.0 中不存在则插入

Question

如果不存在，我正在尝试插入，我发现 this post 用于 1.0.1、2.0。

中找到了交易使用片段

val a = (for {
  ns <- coffees.filter(_.name.startsWith("ESPRESSO")).map(_.name).result
  _ <- DBIO.seq(ns.map(n => coffees.filter(_.name === n).delete): _*)
} yield ()).transactionally

val f: Future[Unit] = db.run(a)

如果此结构不存在，我正在努力编写插入逻辑。我是 Slick 的新手，对 Scala 没有什么经验。如果事务外不存在，这是我尝试插入...

val result: Future[Boolean] = db.run(products.filter(_.name==="foo").exists.result)
result.map { exists =>  
  if (!exists) {
    products += Product(
      None,
      productName,
      productPrice
    ) 
  }  
}

但是我如何将其放入事务块中？这是我能走的最远的地方：

val a = (for {
  exists <- products.filter(_.name==="foo").exists.result
  //???  
//    _ <- DBIO.seq(ns.map(n => coffees.filter(_.name === n).delete): _*)
} yield ()).transactionally

提前致谢

Answer 1

这是我想出的版本：

val a = (
    products.filter(_.name==="foo").exists.result.flatMap { exists => 
      if (!exists) {
        products += Product(
          None,
          productName,
          productPrice
        ) 
      } else {
        DBIO.successful(None) // no-op
      }
    }
).transactionally

虽然有点欠缺，例如它对 return 插入的或现有的对象很有用。

为完整起见，此处 table 定义：

case class DBProduct(id: Int, uuid: String, name: String, price: BigDecimal)
class Products(tag: Tag) extends Table[DBProduct](tag, "product") {
  def id = column[Int]("id", O.PrimaryKey, O.AutoInc) // This is the primary key column
  def uuid = column[String]("uuid")
  def name = column[String]("name")
  def price = column[BigDecimal]("price", O.SqlType("decimal(10, 4)"))

  def * = (id, uuid, name, price) <> (DBProduct.tupled, DBProduct.unapply)
}
val products = TableQuery[Products]

我正在使用映射 table，该解决方案也适用于元组，只是稍作改动。

另请注意，根据 documentation ，它在插入操作中被忽略：

没有必要将 id 定义为可选

When you include an AutoInc column in an insert operation, it is silently ignored, so that the database can generate the proper value

这里是方法：

def insertIfNotExists(productInput: ProductInput): Future[DBProduct] = {

  val productAction = (
    products.filter(_.uuid===productInput.uuid).result.headOption.flatMap { 
    case Some(product) =>
      mylog("product was there: " + product)
      DBIO.successful(product)

    case None =>
      mylog("inserting product")

      val productId =
        (products returning products.map(_.id)) += DBProduct(
            0,
            productInput.uuid,
            productInput.name,
            productInput.price
            )

          val product = productId.map { id => DBProduct(
            id,
            productInput.uuid,
            productInput.name,
            productInput.price
          )
        }
      product
    }
  ).transactionally

  db.run(productAction)
}

（感谢 Google group thread 的 Matthew Pocock 指导我使用此解决方案）。

Answer 2

根据 slick 3.0 手动插入查询部分（http://slick.typesafe.com/doc/3.0.0/queries.html），插入的值可以返回 id 如下：

def insertIfNotExists(productInput: ProductInput): Future[DBProduct] = {

  val productAction = (
    products.filter(_.uuid===productInput.uuid).result.headOption.flatMap { 
    case Some(product) =>
      mylog("product was there: " + product)
      DBIO.successful(product)

    case None =>
      mylog("inserting product")

      (products returning products.map(_.id) 
                into ((prod,id) => prod.copy(id=id))) += DBProduct(
            0,
            productInput.uuid,
            productInput.name,
            productInput.price
            )
    }
  ).transactionally

  db.run(productAction)
}

Answer 3

可以使用单个 insert ... if not exists 查询。这避免了多次数据库往返和竞争条件（事务可能不够，具体取决于隔离级别）。

def insertIfNotExists(name: String) = users.forceInsertQuery {
  val exists = (for (u <- users if u.name === name.bind) yield u).exists
  val insert = (name.bind, None) <> (User.apply _ tupled, User.unapply)
  for (u <- Query(insert) if !exists) yield u
}

Await.result(db.run(DBIO.seq(
  // create the schema
  users.schema.create,

  users += User("Bob"),
  users += User("Bob"),
  insertIfNotExists("Bob"),
  insertIfNotExists("Fred"),
  insertIfNotExists("Fred"),

  // print the users (select * from USERS)
  users.result.map(println)
)), Duration.Inf)

输出：

Vector(User(Bob,Some(1)), User(Bob,Some(2)), User(Fred,Some(3)))

生成SQL:

insert into "USERS" ("NAME","ID") select ?, null where not exists(select x2."NAME", x2."ID" from "USERS" x2 where x2."NAME" = ?)

Here's the full example on github

Answer 4

我已经运行找到看起来更完整的解决方案。 Essential Slick 书中的 Section 3.1.7 More Control over Inserts 有示例。

最后你会得到这样的东西：

  val entity = UserEntity(UUID.random, "jay", "jay@localhost")

  val exists =
    users
      .filter(
        u =>
          u.name === entity.name.bind
            && u.email === entity.email.bind
      )
      .exists
  val selectExpression = Query(
    (
      entity.id.bind,
      entity.name.bind,
      entity.email.bind
    )
  ).filterNot(_ => exists)

  val action = usersDecisions
    .map(u => (u.id, u.name, u.email))
    .forceInsertQuery(selectExpression)

  exec(action)
  // res17: Int = 1

  exec(action)
  // res18: Int = 0

如果 Slick 3.0.0 中不存在则插入

Insert if not exists in Slick 3.0.0

scala

slick