DeleteAll ParseObjects

darwish · July 6, 2022, 1:39pm

Hello,

I am sorry for what seems like a basic question but I am very new to ParseSwift.
how can i delete all records like in other SDK? other than the current solution that comes to mind is running it via cloud code as my custom parseObjects has as ParseFile and I would like to erase the object and any referencing files.

Edit:
After some tinkering around i found a solution that works but I’m not so sure that its the correct way. if anyone can shed some light I would be grateful.

I have a custom ParseObject called ParseCandidate

ParseCandidate.query.find().deleteAll{ response in
  //do something with response
}

This gets the job done but I am quit certain that any attached ParseFile will not be deleted and I will have to do some housekeeping to delete unreferenced files.

thank you.

cbaker6 · July 7, 2022, 3:22am

The playgrounds demonstrate how to use most the SDKs functionality. DeleteAll is here:

github.com

parse-community/Parse-Swift/blob/b0bdf71dfe2890b44910c06382af98e17726fa96/ParseSwift.playground/Pages/1 - Your first Object.xcplaygroundpage/Contents.swift#L334-L349


      
          //: Asynchronously (preferred way) deleteAll GameScores based on it's objectId alone.
          [scoreToFetch, score2ToFetch].deleteAll { result in
              switch result {
              case .success(let deletedScores):
                  deletedScores.forEach { result in
                      switch result {
                      case .success:
                          print("Successfully deleted score")
                      case .failure(let error):
                          print("Error deleting: \(error)")
                      }
                  }
              case .failure(let error):
                  assertionFailure("Error deleting: \(error)")
              }
          }

Deleting a file is similar to the other SDKs and requires the masterKey which the documentation states. This type of functionality should only be used server side. To use the Swift SDK for cloud code see here:

darwish · July 12, 2022, 9:19am

Thank you @cbaker6

Believe i went through the playgrounds multiple times before posting this question but must have skimmed right past it.

I just have a one question though. it seems to me that this method is iterating through the array and deleting on object at a time. if i call this method from a local device will this be all accomplished on one api call or multiples, Now i am certain if this was run on cloud code its one api call to the server then the server does it thing and sends the response back.

Thanks again for shedding some light.

cbaker6 · July 12, 2022, 11:01am

All of the SDK is documented. You can see the documentation for a method or property by right clicking in Xcode. For deleteAll everything is “batched” meaning all objects in the array are sent to the server based on the batched limit. As long as your array is smaller/equal to the batch limit everything is sent at once. The same thing occurs when using the JS SDK and Cloud Cloud:

github.com

parse-community/Parse-Swift/blob/926fc0552405c08475b259c92901e01ec440999b/Sources/ParseSwift/Objects/ParseObject.swift#L727-L750


      
          /**
           Deletes a collection of objects all at once *asynchronously* and executes the completion block when done.
           - parameter batchLimit: The maximum number of objects to send in each batch. If the items to be batched.
           is greater than the `batchLimit`, the objects will be sent to the server in waves up to the `batchLimit`.
           Defaults to 50.
           - parameter transaction: Treat as an all-or-nothing operation. If some operation failure occurs that
           prevents the transaction from completing, then none of the objects are committed to the Parse Server database.
           - parameter options: A set of header options sent to the server. Defaults to an empty set.
           - parameter callbackQueue: The queue to return to after completion. Default value of .main.
           - parameter completion: The block to execute.
           It should have the following argument signature: `(Result<[ParseError?], ParseError>)`.
           Each element in the array is `nil` if the delete successful or a `ParseError` if it failed.
           1. A `ParseError.Code.aggregateError`. This object's "errors" property is an
           array of other Parse.Error objects. Each error object in this array
           has an "object" property that references the object that could not be
           deleted (for instance, because that object could not be found).
           2. A non-aggregate Parse.Error. This indicates a serious error that
           caused the delete operation to be aborted partway through (for
           instance, a connection failure in the middle of the delete).
           - warning: If `transaction = true`, then `batchLimit` will be automatically be set to the amount of the

This file has been truncated. show original

darwish · November 1, 2022, 6:38pm

I have a follow up question. I have managed to setup the deleteAll() however I have an object that has many children. Is there a way to include all children in the delete process?

Thank you

cbaker6 · November 1, 2022, 9:18pm

I don’t believe the server supports this out-of-the-box. You will need to create a custom cloud code method. You can either create the cloud in JS or using Swift.