Tasks

Creating a Query for a Class

• + queryWithClassName:

  Returns a PFQuery for a given class.

• + queryWithClassName:predicate:

  Creates a PFQuery with the constraints given by predicate.

• – initWithClassName:

  Initializes the query with a class name.

•   parseClassName

  The class name to query for

  property

Adding Basic Constraints

• – includeKey:

  Make the query include PFObjects that have a reference stored at the provided key.
  This has an effect similar to a join. You can use dot notation to specify which fields in
  the included object are also fetch.

• – whereKeyExists:

  Add a constraint that requires a particular key exists.

• – whereKeyDoesNotExist:

  Add a constraint that requires a key not exist.

• – whereKey:equalTo:

  Add a constraint to the query that requires a particular key’s object to be equal to the provided object.

• – whereKey:lessThan:

  Add a constraint to the query that requires a particular key’s object to be less than the provided object.

• – whereKey:lessThanOrEqualTo:

  Add a constraint to the query that requires a particular key’s object to be less than or equal to the provided object.

• – whereKey:greaterThan:

  Add a constraint to the query that requires a particular key’s object to be greater than the provided object.

• – whereKey:greaterThanOrEqualTo:

  Add a constraint to the query that requires a particular key’s object to be greater than or equal to the provided object.

• – whereKey:notEqualTo:

  Add a constraint to the query that requires a particular key’s object to be not equal to the provided object.

• – whereKey:containedIn:

  Add a constraint to the query that requires a particular key’s object to be contained in the provided array.

• – whereKey:notContainedIn:

  Add a constraint to the query that requires a particular key’s object not be contained in the provided array.

• – whereKey:containsAllObjectsInArray:

  Add a constraint to the query that requires a particular key’s array contains every element of the provided array.

Adding Location Constraints

• – whereKey:nearGeoPoint:

  Add a constraint to the query that requires a particular key’s coordinates (specified via PFGeoPoint) be near
  a reference point. Distance is calculated based on angular distance on a sphere. Results will be sorted by distance
  from reference point.

• – whereKey:nearGeoPoint:withinMiles:

  Add a constraint to the query that requires a particular key’s coordinates (specified via PFGeoPoint) be near
  a reference point and within the maximum distance specified (in miles). Distance is calculated based on
  a spherical coordinate system. Results will be sorted by distance (nearest to farthest) from the reference point.

• – whereKey:nearGeoPoint:withinKilometers:

  Add a constraint to the query that requires a particular key’s coordinates (specified via PFGeoPoint) be near
  a reference point and within the maximum distance specified (in kilometers). Distance is calculated based on
  a spherical coordinate system. Results will be sorted by distance (nearest to farthest) from the reference point.

• – whereKey:nearGeoPoint:withinRadians:

  Add a constraint to the query that requires a particular key’s coordinates (specified via PFGeoPoint) be near
  a reference point and within the maximum distance specified (in radians). Distance is calculated based on
  angular distance on a sphere. Results will be sorted by distance (nearest to farthest) from the reference point.

• – whereKey:withinGeoBoxFromSouthwest:toNortheast:

  Add a constraint to the query that requires a particular key’s coordinates (specified via PFGeoPoint) be
  contained within a given rectangular geographic bounding box.

Adding String Constraints

• – whereKey:matchesRegex:

  Add a regular expression constraint for finding string values that match the provided regular expression.
  This may be slow for large datasets.

• – whereKey:matchesRegex:modifiers:

  Add a regular expression constraint for finding string values that match the provided regular expression.
  This may be slow for large datasets.

• – whereKey:containsString:

  Add a constraint for finding string values that contain a provided substring.
  This will be slow for large datasets.

• – whereKey:hasPrefix:

  Add a constraint for finding string values that start with a provided prefix.
  This will use smart indexing, so it will be fast for large datasets.

• – whereKey:hasSuffix:

  Add a constraint for finding string values that end with a provided suffix.
  This will be slow for large datasets.

Adding Subqueries

• + orQueryWithSubqueries:

  Returns a PFQuery that is the or of the passed in PFQuerys.

• – whereKey:matchesKey:inQuery:

  Adds a constraint that requires that a key’s value matches a value in another key
  in objects returned by a sub query.

• – whereKey:doesNotMatchKey:inQuery:

  Adds a constraint that requires that a key’s value NOT match a value in another key
  in objects returned by a sub query.

• – whereKey:matchesQuery:

  Add a constraint that requires that a key’s value matches a PFQuery constraint.
  This only works where the key’s values are PFObjects or arrays of PFObjects.

• – whereKey:doesNotMatchQuery:

  Add a constraint that requires that a key’s value to not match a PFQuery constraint.
  This only works where the key’s values are PFObjects or arrays of PFObjects.

Sorting

• – orderByAscending:

  Sort the results in ascending order with the given key.

• – addAscendingOrder:

  Also sort in ascending order by the given key. The previous keys provided will
  precedence over this key.

• – orderByDescending:

  Sort the results in descending order with the given key.

• – addDescendingOrder:

  Also sort in descending order by the given key. The previous keys provided will
  precedence over this key.

• – orderBySortDescriptor:

  Sort the results in descending order with the given descriptor.

• – orderBySortDescriptors:

  Sort the results in descending order with the given descriptors.

Getting Objects by ID

• + getObjectOfClass:objectId:

  Returns a PFObject with a given class and id.

• + getObjectOfClass:objectId:error:

  Returns a PFObject with a given class and id and sets an error if necessary.

• – getObjectWithId:

  Returns a PFObject with the given id.

• – getObjectWithId:error:

  Returns a PFObject with the given id and sets an error if necessary.

• – getObjectInBackgroundWithId:block:

  Gets a PFObject asynchronously and calls the given block with the result.

• – getObjectInBackgroundWithId:target:selector:

  Gets a PFObject asynchronously.

Getting User Objects

• + getUserObjectWithId:

  Returns a PFUser with a given id.

• + getUserObjectWithId:error:

  Returns a PFUser with a given class and id and sets an error if necessary.

• + queryForUser

  Deprecated. Please use [PFUser query] instead.

Getting all Matches for a Query

• – findObjects

  Finds objects based on the constructed query.

• – findObjects:

  Finds objects based on the constructed query and sets an error if there was one.

• – findObjectsInBackgroundWithBlock:

  Finds objects asynchronously and calls the given block with the results.

• – findObjectsInBackgroundWithTarget:selector:

  Finds objects asynchronously and calls the given callback with the results.

Getting the First Match in a Query

• – getFirstObject

  Gets an object based on the constructed query.

• – getFirstObject:

  Gets an object based on the constructed query and sets an error if any occurred.

• – getFirstObjectInBackgroundWithBlock:

  Gets an object asynchronously and calls the given block with the result.

• – getFirstObjectInBackgroundWithTarget:selector:

  Gets an object asynchronously and calls the given callback with the results.

Counting the Matches in a Query

• – countObjects

  Counts objects based on the constructed query.

• – countObjects:

  Counts objects based on the constructed query and sets an error if there was one.

• – countObjectsInBackgroundWithBlock:

  Counts objects asynchronously and calls the given block with the counts.

• – countObjectsInBackgroundWithTarget:selector:

  Counts objects asynchronously and calls the given callback with the count.

Cancelling a Query

• – cancel

  Cancels the current network request (if any). Ensures that callbacks won’t be called.

Paginating Results

•   limit

  A limit on the number of objects to return. The default limit is 100, with a
  maximum of 1000 results being returned at a time.

  property
•   skip

  The number of objects to skip before returning any.

  property

Controlling Caching Behavior

•   cachePolicy

  The cache policy to use for requests.

  property
• – hasCachedResult

  Returns whether there is a cached result for this query.

• – clearCachedResult

  Clears the cached result for this query. If there is no cached result, this is a noop.

• + clearAllCachedResults

  Clears the cached results for all queries.

Advanced Settings

•   trace

  Whether or not performance tracing should be done on the query.
  This should not be set in most cases.

  property