删除记录时在 ScalarDB 中获取 InvalidUsageException

Question

I am using ScalarDB which provides ACID functionality on Cassandra . While deleting a record, I am getting com.scalar.db.exception.transaction.InvalidUsageException: the record to be deleted must be existing and read beforehand exception.

I am deleting entries from several tables (thus using Scalar to provide Atomocity). I created a DistributedTransaction at the start and then started deleting the entries.

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)
  }

All steps before commitTransaction seem to be ok but `commitTransaction fails with error

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)

Referring to https://scalardl.readthedocs.io/en/latest/trouble-shooting-guide/ , it seems blind delete is not allowed. But I have tried doing a get before delete and have also tried to put conditions like DeleteIfExists but I am still getting the error.

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)
  }

Why do I have to get a record before deleting it? What is the way to delete straightaway? Am I not using the library correctly?

Answer 1

As it turns out, the problem was in my code. Firstly, we have to do a get before doing a delete . I don't know why but that is the rule it seems.

So I added a get in each 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)


  }

The reason I was getting the exception despite adding get earlier was due to programming issues (mistakes in assigning variables correctly). Say the delete was for record A but I hadn't stored A correctly but had stored it as A1 . So the get was actually failing.

In general, I think this error means that the record being deleted doesn't exist.