2

我有一个人表和动物表，在动物表中有对 personId 的 FK，因为它们之间存在一对多的关系。

我只想创建一个人并使用事务创建它的动物，因为我希望该过程是原子的（如果我无法创建它的动物，则数据库中没有使用人）

这是我如何接受人员创建请求的模型：

case class PersonCreateRequest(name: String, age: Int, animals: Seq[AnimalCreateRequest])

这就是数据库如何认识一个人：

case class Person(personId: Long, name, age: Int)

// this is just a companion object to help me take a PersonCreateRequest and make it Person
object Person {
  def apply(person: PersonCreateRequest): Person = {
    Person(0L,
           person.name,
           person.age)
  }
}

我对动物有同样的事情：

case class AnimalCreateRequest(animalType: String, age: Int)

这就是数据库知道动物（personId = owner）的方式：

case class Animal(animalId: Long, animalType: String, age: Int, personId: Long)

// here I need to get personId as parameter cause I will only have it after a person was created:
object Animal {
  def apply(animal: AnimalCreateRequest, personId: Long): Animal = {
    Animal(0L,
           animal.animalType,
           animal.age,
           personId)
  }
}

所以现在这就是我尝试这样做的方式（但失败了）： 

lazy val ctx = new MysqlAsyncContext(CamelCase, "ctx")
  import ctx._


  def insertPerson(personToCreate: PersonCreateRequest): Future[Long] = {

    // getting the person object that the db knows
    val dbPerson = Person.apply(personToCreate)

    // INSERT Person Query
    val insertPersonQuery = quote {
      query[Person].insert(lift(dbPerson)).returning(_.personId)
    }

    ctx.transaction { implicit ec =>
      for {
        personId   <- ctx.run(insertPersonQuery)
        contactIds <- {
          Future.sequence(
          personToCreate.animals.map(animal => {
            val animalToInsert = Animal.apply(animal, personId)
            insertAnimal(animalToInsert)
          })
          )
        }
      } yield personId
    }
  }

  def insertAnimal(animal: Animal): Future[Long] = {
    val q = quote {
      query[Animal].insert(lift(animal)).returning(_.animalId)
    }
    ctx.run(q)
  }

发生的事情是我只是没有得到响应......它继续处理而不返回任何内容或抛出错误

4

3 回答 3

2

问题是，目前，Quill async 不支持事务内的并发操作。

所以必须按顺序进行动物插入：

ctx.transaction { implicit ec =>
  for {
    personId <- ctx.run(insertPersonQuery)
    animals = personCreate.animals.map(Animal.apply(personId, _))
    _ <- animals.foldLeft(Future.successful(0l)) {
      case (fut, animal) =>
        fut.flatMap(_ => insertAnimal(animal))
    }
  } yield personId
}

另外，更好的是使用批量插入:)

感谢@fwbrasil 和@mentegy 的帮助！

于 2018-01-30T13:09:31.200 回答
0

你熟悉Scala 期货吗？

要从事务中获取结果，您应该将onSuccess处理程序添加到调用Future返回的对象中ctx.transaction：

ctx.transaction { ...
}.onSuccess {
  case personId => ...
}
于 2018-01-29T10:45:09.230 回答
0

向方法添加隐式ExecutionContext参数insertAnimal：

def insertAnimal(animal: Animal)(implicit ec: ExecutionContext): Future[Long] =

没有它，您就不会从事务块中传递 ec ，并且动物插入将尝试并使用池中的其他连接。

于 2018-01-29T07:27:03.473 回答