```objective_c
@@ -24,7 +24,7 @@ PFObject *gameScore = [PFObject objectWithClassName:@"GameScore"];
gameScore[@"score"] = @1337;
gameScore[@"playerName"] = @"Sean Plott";
gameScore[@"cheatMode"] = @NO;
-[gameScore saveInBackgroundWithBlock:^(BOOL succeeded, NSError *error) {
+[gameScore saveInBackgroundWithBlock:^(BOOL succeeded, NSError * _Nullable error) {
if (succeeded) {
// The object has been saved.
} else {
@@ -37,18 +37,17 @@ let gameScore = PFObject(className:"GameScore")
gameScore["score"] = 1337
gameScore["playerName"] = "Sean Plott"
gameScore["cheatMode"] = false
-gameScore.saveInBackground {
- (success: Bool, error: Error?) in
- if (success) {
- // The object has been saved.
- } else {
- // There was a problem, check error.description
- }
+gameScore.saveInBackground { (succeeded, error) in
+ if (succeeded) {
+ // The object has been saved.
+ } else {
+ // There was a problem, check error.description
+ }
}
```
-After this code runs, you will probably be wondering if anything really happened. To make sure the data was saved, you can look at the Data Browser in your app on Parse. You should see something like this:
+After this code runs, you will probably be wondering if anything really happened. If [Parse Dashboard](https://github.com/parse-community/parse-dashboard) is implemented for your server, you can verify the data was saved in the data browser. You should see something like this:
```js
objectId: "xWMyZ4YEGZ", score: 1337, playerName: "Sean Plott", cheatMode: false,
@@ -57,9 +56,7 @@ createdAt:"2011-06-10T18:33:42Z", updatedAt:"2011-06-10T18:33:42Z"
There are two things to note here. You didn't have to configure or set up a new Class called `GameScore` before running this code. Your Parse app lazily creates this Class for you when it first encounters it.
-There are also a few fields you don't need to specify that are provided as a convenience. `objectId` is a unique identifier for each saved object. `createdAt` and `updatedAt` represent the time that each object was created and last modified in the Parse Cloud. Each of these fields is filled in by Parse, so they don't exist on a `PFObject` until a save operation has completed.
-
-Note: You can use the `saveInBackgroundWithBlock` method to provide additional logic to run after the save completes.
+There are also a few fields you don't need to specify that are provided and set by the system as a convenience. `objectId` is a unique identifier for each saved object. `createdAt` and `updatedAt` represent the time that each object was created or last modified and saved to the Parse Server. Each of these fields is filled in by Parse Server, so they don't exist on a `PFObject` until the first save operation has been completed.
## Retrieving Objects
@@ -69,22 +66,20 @@ Saving data to the cloud is fun, but it's even more fun to get that data out aga
```objective_c
PFQuery *query = [PFQuery queryWithClassName:@"GameScore"];
[query getObjectInBackgroundWithId:@"xWMyZ4YEGZ" block:^(PFObject *gameScore, NSError *error) {
- // Do something with the returned PFObject in the gameScore variable.
- NSLog(@"%@", gameScore);
+ if (!error) {
+ // Success!
+ } else {
+ // Failure!
+ }
}];
-// The InBackground methods are asynchronous, so any code after this will run
-// immediately. Any code that depends on the query result should be moved
-// inside the completion block above.
```
```swift
let query = PFQuery(className:"GameScore")
-query.getObjectInBackground(withId: "xWMyZEGZ") { (gameScore: PFObject?, error: Error?) in
- if let error = error {
- //The query returned an error
- print(error.localizedDescription)
+query.getObjectInBackground(withId: "xWMyZEGZ") { (gameScore, error) in
+ if error == nil {
+ // Success!
} else {
- //The object has been retrieved
- print(gameScore)
+ // Fail!
}
}
```
@@ -123,22 +118,35 @@ let acl = gameScore.acl
If you need to refresh an object you already have with the latest data that
- is in the Parse Cloud, you can call the `fetch` method like so:
+is in the database, you can use the `fetchInBackgroundWithBlock:` or `fetchInBackgroundWithTarget:selector:` methods.
+
```objective_c
-[myObject fetch];
+[myObject fetchInBackgroundWithBlock:^(PFObject * _Nullable object, NSError * _Nullable error) {
+ if (!error) {
+ // Success!
+ } else {
+ // Failure!
+ }
+}];
```
```swift
-myObject.fetch()
+myObject.fetchInBackground { (object, error) in
+ if error == nil {
+ // Success!
+ } else {
+ // Failure!
+ }
+}
```
-Note: In a similar way to the `save` methods, you can use the `fetchInBackgroundWithBlock` or `fetchInBackgroundWithTarget:selector:` methods to provide additional logic which will run after fetching the object.
+Note: In a similar way to the `save` methods, you can use the throwable `fetch` or `fetchIfNeeded` methods, or asyncronous task without completion. `fetchInBackground`
## The Local Datastore
-Parse also lets you store objects in a [local datastore](#local-datastore) on the device itself. You can use this for data that doesn't need to be saved to the cloud, but this is especially useful for temporarily storing data so that it can be synced later. To enable the datastore, add `libsqlite3.dylib` and add `isLocalDatastoreEnabled = true` to the `ParseClientConfiguration` block in your `AppDelegate` `application:didFinishLaunchWithOptions:` before calling `Parse.initialize()`. Once the local datastore is enabled, you can store an object by pinning it.
+Parse also lets you store objects in a [local datastore](#local-datastore) on the device itself. You can use this for data that doesn't need to be saved to the cloud, but this is especially useful for temporarily storing data so that it can be synced later. To enable the datastore, add `isLocalDatastoreEnabled = true` to the `ParseClientConfiguration` block in your `AppDelegate` `application:didFinishLaunchWithOptions:`, or call `Parse.enableLocalDatastore()` before calling `Parse.initialize()`. Once the local datastore is enabled, you can store an object by pinning it.
```objective_c
@@ -161,7 +169,7 @@ As with saving, this recursively stores every object and file that `gameScore` p
### Retrieving Objects from the Local Datastore
-Storing an object is only useful if you can get it back out. To get the data for a specific object, you can use a `PFQuery` just like you would while on the network, but using the `fromLocalDatastore` method to tell it where to get the data.
+Storing an object is only useful if you can get it back out. To get the data for a specific object, you can use a `PFQuery` just like you would while on the network, but using the `fromLocalDatastore:` method to tell it where to get the data.
```objective_c
@@ -192,7 +200,7 @@ query.getObjectInBackground(withId: "xWMyZEGZ").continueWith { (task: BFTask
-If you already have an instance of the object, you can instead use the `fetchFromLocalDatastoreInBackground` method.
+If you already have an instance of the object, you can instead use the `fetchFromLocalDatastoreInBackground:` method.
```objective_c
@@ -223,7 +231,7 @@ object.fetchFromLocalDatastoreInBackground().continueWith { (task: BFTask
```objective_c
@@ -236,7 +244,7 @@ gameScore.unpinInBackground()
## Saving Objects Offline
-Most save functions execute immediately, and inform your app when the save is complete. If you don't need to know when the save has finished, you can use `saveEventually` instead. The advantage is that if the user currently doesn't have a network connection, `saveEventually` will store the update on the device until a network connection is re-established. If your app is closed before the connection is back, Parse will try again the next time the app is opened. All calls to `saveEventually` (and `deleteEventually`) are executed in the order they are called, so it is safe to call `saveEventually` on an object multiple times.
+Most save functions execute immediately, and inform your app when the save is complete. For a network consious soltion on non-priority save requests use `saveEventually`. Not only does it retry saving upon regaining network connection, but If your app is closed prior to save completion Parse will try the next time the app is opened. Additionally, all calls to `saveEventually` (and `deleteEventually`) are executed in the order they are called, making it safe to call `saveEventually` on an object multiple times.
```objective_c
@@ -344,43 +352,39 @@ gameScore.saveInBackground()
```
-Note that it is not currently possible to atomically add and remove items from an array in the same save.
- You will have to call `save` in between every different kind of array operation.
+Note that it is not currently possible to atomically add and remove items from an array in the same save using. You will have to call `save` in between every different kind of array operation.
## Deleting Objects
-To delete an object from the cloud:
-
-```objective_c
-[gameScore deleteInBackground];
-```
-```swift
-gameScore.deleteInBackground()
-```
-
+There are a few ways to delete a `PFObject`. For basic asynchronous deletion of a single object call the objects `deleteInBackground` function. If you prefer to recieve a callback you can use the `deleteInBackgroundWithBlock:` or `deleteInBackgroundWithTarget:selector:` methods. If you want to block the calling thread, you can use the `delete` method. Lastly, `deleteEventually` is a network conscious option that deletes when possible but does not guarantee a timeframe for the tasks completion.
-If you want to run a callback when the delete is confirmed, you can use the `deleteInBackgroundWithBlock:` or `deleteInBackgroundWithTarget:selector:` methods. If you want to block the calling thread, you can use the `delete` method.
+For deleting multiple objects use the `PFObject` static function `deleteAllInBackground` to delete an array of objects asynchronously. The same can be done while blocking the calling thread using `deleteAll`. Lastly, to recieve a callback after deleting objects asyncronously use `deleteAllInBackground:block:` as demonstrated below.
-You can delete a single field from an object with the `removeObjectForKey` method:
```objective_c
-// After this, the playerName field will be empty
-[gameScore removeObjectForKey:@"playerName"];
-
-// Saves the field deletion to the Parse Cloud
-[gameScore saveInBackground];
+[PFObject deleteAllInBackground:objectArray block:^(BOOL succeeded, NSError * _Nullable error) {
+ if (succeeded) {
+ // The array of objects was successfully deleted.
+ } else {
+ // There was an error. Check the errors localizedDescription.
+ }
+}];
```
```swift
-// After this, the playerName field will be empty
-gameScore.remove(forKey: "playerName")
-
-// Saves the field deletion to the Parse Cloud
-gameScore.saveInBackground()
+PFObject.deleteAll(inBackground: objectArray) { (succeeded, error) in
+ if (succeeded) {
+ // The array of objects was successfully deleted.
+ } else {
+ // There was an error. Check the errors localizedDescription.
+ }
+}
```
+Note: Deleting an object from the server that contains a `PFFileObject` does **NOT** delete the file from storage. Instead, an objects deletion only deletes the data referencing the stored file. To delete the data from storage you must use the [REST API]({{site.baseUrl}}/rest/guide/#deleting-files). For more info about `PFFileObject`, please see the [Files](#files) section.
+
## Relational Data
Objects can have relationships with other objects. To model this behavior, any `PFObject` can be used as a value in other `PFObject`s. Internally, the Parse framework will store the referred-to object in just one place, to maintain consistency.
@@ -422,16 +426,19 @@ myComment.saveInBackground()
```
```objective_c
-// Add a relation between the Post with objectId "1zEcyElZ80" and the comment
-myComment[@"parent"] = [PFObject objectWithoutDataWithClassName:@"Post" objectId:@"1zEcyElZ80"];
+myComment[@"post"] = [PFObject objectWithoutDataWithClassName:@"Post" objectId:@"1zEcyElZ80"];
```
```swift
// Add a relation between the Post with objectId "1zEcyElZ80" and the comment
-myComment["parent"] = PFObject(withoutDataWithClassName:"Post", objectId:"1zEcyElZ80")
+myComment["post"] = PFObject(withoutDataWithClassName: "Post", objectId: "1zEcyElZ80")
```
@@ -439,17 +446,20 @@ By default, when fetching an object, related `PFObject`s are not fetched. These
```objective_c
-PFObject *post = fetchedComment[@"parent"];
-[post fetchIfNeededInBackgroundWithBlock:^(PFObject *post, NSError *error) {
- NSString *title = post[@"title"];
- // do something with your title variable
+PFObject *post = myComment[@"post"];
+[post fetchInBackgroundWithBlock:^(PFObject * _Nullable object, NSError * _Nullable error) {
+ NSString *title = post[@"title"];
+ if (title) { // do something with title }
}];
```
```swift
let post = myComment["parent"] as! PFObject
-post.fetchIfNeededInBackground { (post: PFObject?, error: Error?) in
- let title = post?["title"] as? String
- // do something with your title variable
+post.fetchIfNeededInBackground { (object, error) in
+ if let title = post["title"] as? String {
+ // do something with your title variable
+ } else if let errorString = error?.localizedDescription {
+ print(errorString)
+ }
}
```
@@ -461,78 +471,75 @@ You can also model a many-to-many relation using the `PFRelation` object. This
PFUser *user = [PFUser currentUser];
PFRelation *relation = [user relationForKey:@"likes"];
[relation addObject:post];
-[user saveInBackgroundWithBlock:^(BOOL succeeded, NSError *error) {
- if (succeeded) {
- // The post has been added to the user's likes relation.
- } else {
- // There was a problem, check error.description
- }
+[user saveInBackgroundWithBlock:^(BOOL succeeded, NSError * _Nullable error) {
+ if (succeeded) {
+ // The post has been added to the user's likes relation.
+ } else {
+ // There was a problem, check error.description
+ }
}];
```
```swift
-let user = PFUser.current()
-let relation = user?.relation(forKey: "likes")
-relation?.add(post)
-user?.saveInBackground(block: { (success: Bool, error: Error?) in
- if (success) {
+guard let user = PFUser.current() else { return }
+let relation = user.relation(forKey: "likes")
+relation.add(post)
+user.saveInBackground { (succeeded, error) in
+ if (succeeded) {
// The post has been added to the user's likes relation.
} else {
// There was a problem, check error.description
}
-})
-
+}
```
-You can remove a post from the `PFRelation` with something like:
-
-
-```objective_c
-[relation removeObject:post];
-```
-```swift
-relation?.remove(post)
-```
-
+You can remove a post from the `PFRelation` similarly using the `removeObject:` function followed by saving the parent object.
By default, the list of objects in this relation are not downloaded. You can get the list of `Post`s by using calling `findObjectsInBackgroundWithBlock:` on the `PFQuery` returned by `query`. The code would look like:
```objective_c
-[[relation query] findObjectsInBackgroundWithBlock:^(NSArray *objects, NSError *error) {
- if (error) {
- // There was an error
- } else {
- // objects has all the Posts the current user liked.
- }
+[[relation query] findObjectsInBackgroundWithBlock:^(NSArray * _Nullable objects, NSError * _Nullable error) {
+ if (error) {
+ // There was an error
+ } else {
+ // objects has all the Posts the current user liked.
+ }
}];
```
```swift
-relation?.query().findObjectsInBackground(block: { (objects: [PFObject]?, error: Error?) in
- if let error = error {
- // There was an error
- print(error.localizedDescription)
+relation.query().findObjectsInBackground { (object, error) in
+ if error == nil {
+ // Success
} else {
- // objects has all the Posts the current user liked.
+ // Failure!
}
})
```
-If you want only a subset of the `Post`s you can add extra constraints to the `PFQuery` returned by `query` like this:
+You can add constraints to a `PFRelation`'s query by adding constraints to the `PFQuery` returned by its `query` parameter as demonstrated below:
```objective_c
PFQuery *query = [relation query];
-// Add other query constraints.
+[query whereKey:"category" equalTo:@"development"];
+PFObject *object = [query getFirstObject]; // Query first object found
+if (object) {
+ // Do something with object
+}
```
```swift
-var query = relation?.query()
-// Add other query constraints.
-```
+var query = relation.query()
+query.whereKey("category", equalTo: "development")
+
+// Query first object found
+if let object = try? query.getFirstObject() {
+ // Do something with object
+} ```
-For more details on `PFQuery` please look at the query portion of this guide. A `PFRelation` behaves similar to an `NSArray` of `PFObject`, so any queries you can do on arrays of objects (other than `includeKey:`) you can do on `PFRelation`.
+You can learn more about queries by visiting the [PFQuery](#queries) section. A `PFRelation` behaves similarly to an array of `PFObject` yet has a built in query that's capable of everything a standard `PFQuery` is other than `includeKey:`.
## Data Types
@@ -596,7 +603,7 @@ bigObject.saveInBackground()
```