删除记录时在ScalarDB中获取ScalarDB

Question

我使用的是ScalarDB，它在Cassandra上提供ACID功能。在删除记录时，我得到了com.scalar.db.exception.transaction.InvalidUsageException: the record to be deleted must be existing and read beforehand异常。

我正在从几个表中删除条目(因此使用Scalar提供Atomocity)。我在开始时创建了一个DistributedTransaction，然后开始删除这些条目。

def deleteQuestion(questionKey:PracticeQuestionKeys,user:User) = {
    logger.trace(s"delete question request ${questionKey}, ${user}")
    val transaction = transactionService.start
    val questionGetResult = getQuestionFromQuestionID(transaction,questionKey)//
    if(questionGetResult.isLeft) throw questionGetResult.left.get
    val question = questionGetResult.right.get
    deleteQuestionIfUserIsAuthorized(transaction,questionKey, question, user)
    deleteQuestionTagFromTagRepository(transaction,question)
    deleteQuestionFromProfileAndPortfolio(transaction, question, user.id)
    commitTransaction(transaction)
  }

commitTransaction之前的所有步骤似乎都正常，但“提交事务”失败时出错

2020-08-02 13:19:12,883 [WARN] from com.scalar.db.transaction.consensuscommit.CommitHandler in scala-execution-context-global-141 - preparing records failed
com.scalar.db.exception.transaction.InvalidUsageException: the record to be deleted must be existing and read beforehand
    at com.scalar.db.transaction.consensuscommit.PrepareMutationComposer.add(PrepareMutationComposer.java:89)
    at com.scalar.db.transaction.consensuscommit.PrepareMutationComposer.add(PrepareMutationComposer.java:45)
    at com.scalar.db.transaction.consensuscommit.Snapshot.lambda$to$1(Snapshot.java:134)
    at java.util.concurrent.ConcurrentHashMap$EntrySetView.forEach(ConcurrentHashMap.java:4795)
    at com.scalar.db.transaction.consensuscommit.Snapshot.to(Snapshot.java:130)
    at com.scalar.db.transaction.consensuscommit.CommitHandler.prepareRecords(CommitHandler.java:104)
    at com.scalar.db.transaction.consensuscommit.CommitHandler.commit(CommitHandler.java:40)
    at com.scalar.db.transaction.consensuscommit.ConsensusCommit.commit(ConsensusCommit.java:121)
    at services.QuestionsTransactionDatabaseService.commitTransaction(QuestionsTransactionDatabaseService.scala:251)
    at services.QuestionsTransactionDatabaseService.deleteQuestion(QuestionsTransactionDatabaseService.scala:388)
    at services.QuestionsTransactionService.$anonfun$deleteQuestion$1(QuestionsTransactionService.scala:57)
    at scala.runtime.java8.JFunction0$mcV$sp.apply(JFunction0$mcV$sp.java:12)
    at scala.concurrent.Future$.$anonfun$apply$1(Future.scala:653)
    at scala.util.Success.$anonfun$map$1(Try.scala:251)
    at scala.util.Success.map(Try.scala:209)
    at scala.concurrent.Future.$anonfun$map$1(Future.scala:287)
    at scala.concurrent.impl.Promise.liftedTree1$1(Promise.scala:29)
    at scala.concurrent.impl.Promise.$anonfun$transform$1(Promise.scala:29)
    at scala.concurrent.impl.CallbackRunnable.run(Promise.scala:60)
    at scala.concurrent.impl.ExecutionContextImpl$AdaptedForkJoinTask.exec(ExecutionContextImpl.scala:140)
    at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)
    at java.util.concurrent.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1056)
    at java.util.concurrent.ForkJoinPool.runWorker(ForkJoinPool.java:1692)
    at java.util.concurrent.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:157)

就https://scalardl.readthedocs.io/en/latest/trouble-shooting-guide/而言，似乎不允许盲目删除。但是，在删除之前，我已经尝试过执行get，也尝试过添加像DeleteIfExists这样的条件，但是我仍然会收到错误。

def delete(transaction:DistributedTransaction,key:PracticeKeys) = {
    logger.trace("Deleting question. Checking if question exists for" + key)
    get(transaction,key) //I have tried with and without commenting getting/reading question before deleting
    //Perform the operations you want to group in the transaction
    val pKey = new Key(new TextValue("id", key.id.toString))
    logger.trace(s"created question keys ${pKey}")
    logger.trace(s"getting question using ${keyspaceName}, ${tablename}")
    val deleteToken:Delete =  new Delete(pKey)
      .forNamespace(keyspaceName)
      .forTable(tablename)
      .withCondition(new DeleteIfExists)

    transaction.delete(deleteToken)
  }

为什么我必须先删除一个记录，然后再删除它？直接删除的方法是什么？我是不是没有正确地使用图书馆？

Answer 1

事实证明，问题出在我的代码中。首先，我们必须先做一个get，然后再做delete。我不知道为什么，但这似乎是规矩。

所以我在每个get中添加了一个delete

def delete(transaction:DistributedTransaction,questionKey:QuestionsCreatedByAUserForATagKeys) = {
    logger.trace(s"deleting question created for tag with key ${questionKey}")
    get(transaction,questionKey) // <-- HERE. I should probably also check if get returned a valid record.
    val pQuestionsCreatedKey = new Key(
      new TextValue("question_creator", questionKey.creator.creatorId.toString),
      new TextValue("tag", questionKey.tag)
    )

    val cQuestionKey = if(questionKey.creationMonth !=0 && questionKey.creationYear !=0 && questionKey.questionId.isDefined){
      new Key(
        new BigIntValue("creation_year", questionKey.creationYear),
        new BigIntValue("creation_month", questionKey.creationMonth),
        new TextValue("question_id", questionKey.questionId.get.toString),
      )
    } else {
      throw CannotDeleteWithoutEntireCompositeKeyException()
    }

    logger.trace(s"deleting question with keys ${pQuestionsCreatedKey},${cQuestionKey}")


    val deleteToken = new Delete(pQuestionsCreatedKey,cQuestionKey)
        .forNamespace(keyspaceName)
        .forTable(tablename)
        .withCondition(new DeleteIfExists)


    logger.trace(s"deleting from user profile ${deleteToken}")
    transaction.delete(deleteToken)


  }

尽管前面添加了get，但我还是得到了异常，原因是编程问题(正确分配变量时出错)。假设删除是为了记录A，但我没有正确地存储A，而是将其存储为A1。因此，get实际上是失败的。

一般来说，我认为这个错误意味着被删除的记录不存在。