ParseQuery

Constructs a Parse.Query that is the AND of the passed in queries. For example:

var compoundQuery = Parse.Query.and(query1, query2, query3);

will create a compoundQuery that is an and of the query1, query2, and query3.

Static method to restore Parse.Query by json representation Internally calling Parse.Query.withJSON

Constructs a Parse.Query that is the NOR of the passed in queries. For example:

const compoundQuery = Parse.Query.nor(query1, query2, query3);

will create a compoundQuery that is a nor of the query1, query2, and query3.

Constructs a Parse.Query that is the OR of the passed in queries. For example:

var compoundQuery = Parse.Query.or(query1, query2, query3);

will create a compoundQuery that is an or of the query1, query2, and query3.

Helper for condition queries

Adds constraint that all of the passed in queries match.

Adds constraint that none of the passed in queries match.

Adds constraint that at least one of the passed in queries matches.

Converts string for regular expression at the beginning

Sorts the results in ascending order by the given key, but can also add secondary sort descriptors without overwriting _order.

Sorts the results in descending order by the given key, but can also add secondary sort descriptors without overwriting _order.

Executes an aggregate query and returns aggregate results

Sorts the results in ascending order by the given key.

Cancels the current network request (if any is running).

Adds a constraint to the query that requires a particular key's value to be contained by the provided list of values. Get objects where all array elements match.

Adds a constraint to the query that requires a particular key's value to be contained in the provided list of values.

Adds a constraint for finding string values that contain a provided string. This may be slow for large datasets.

Adds a constraint to the query that requires a particular key's value to contain each one of the provided list of values.

Adds a constraint to the query that requires a particular key's value to contain each one of the provided list of values starting with given strings.

Counts the number of objects that match this query.

Sorts the results in descending order by the given key.

Executes a distinct query and returns unique values

Adds a constraint for finding objects that do not contain a given key.

Adds a constraint that requires that a key's value not match a value in an object returned by a different Parse.Query.

Adds a constraint that requires that a key's value not matches a Parse.Query constraint.

Iterates over each result of a query, calling a callback for each one. If the callback returns a promise, the iteration will not continue until that promise has been fulfilled. If the callback returns a rejected promise, then iteration will stop with that error. The items are processed in an unspecified order. The query may not have any sort order, and may not use limit or skip.

Iterates over objects matching a query, calling a callback for each batch. If the callback returns a promise, the iteration will not continue until that promise has been fulfilled. If the callback returns a rejected promise, then iteration will stop with that error. The items are processed in an unspecified order. The query may not have any sort order, and may not use limit or skip.

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

Adds a constraint to the query that requires a particular key's value to be equal to the provided value.

Restricts the fields of the returned Parse.Objects to all keys except the provided keys. Exclude takes precedence over select and include.

Requires Parse Server 3.6.0+

Adds a constraint for finding objects that contain the given key.

Investigates the query execution plan. Useful for optimizing queries. (https://docs.mongodb.com/manual/reference/operator/meta/explain/)

Iterates over each result of a query, calling a callback for each one. If the callback returns a promise, the iteration will not continue until that promise has been fulfilled. If the callback returns a rejected promise, then iteration will stop with that error. The items are processed in an unspecified order. The query may not have any sort order, and may not use limit or skip.

Retrieves a list of ParseObjects that satisfy this query.

Retrieves a complete list of ParseObjects that satisfy this query. Using eachBatch under the hood to fetch all the valid objects.

Retrieves at most one Parse.Object that satisfies this query.

Returns the object if there is one, otherwise undefined.

Changes the source of this query to all pinned objects.

Change the source of this query to the server.

Changes the source of this query to the default group of pinned objects.

Changes the source of this query to a specific group of pinned objects.

Adds a constraint for finding string values that contain a provided string. This may be slow for large datasets. Requires Parse-Server > 2.5.0

In order to sort you must use select and ascending ($score is required)

  query.fullText('field', 'term');
  query.ascending('$score');
  query.select('$score');
 

To retrieve the weight / rank

  object->get('score');
 

You can define optionals by providing an object as a third parameter

  query.fullText('field', 'term', { language: 'es', diacriticSensitive: true });
 

Constructs a Parse.Object whose id is already known by fetching data from the server. Unlike the first method, it never returns undefined.

Adds a constraint to the query that requires a particular key's value to be greater than the provided value.

Adds a constraint to the query that requires a particular key's value to be greater than or equal to the provided value.

Adds a hint to force index selection. (https://docs.mongodb.com/manual/reference/operator/meta/hint/)

Includes nested Parse.Objects for the provided key. You can use dot notation to specify which fields in the included object are also fetched.

You can include all nested Parse.Objects by passing in '*'. Requires Parse Server 3.0.0+

query.include('*');

Includes all nested Parse.Objects one level deep.

Requires Parse Server 3.0.0+

Adds a constraint to the query that requires a particular key's value to be less than the provided value.

Adds a constraint to the query that requires a particular key's value to be less than or equal to the provided value.

Sets the limit of the number of results to return. The default limit is 100.

Iterates over each result of a query, calling a callback for each one. If the callback returns a promise, the iteration will not continue until that promise has been fulfilled. If the callback returns a rejected promise, then iteration will stop with that error. The items are processed in an unspecified order. The query may not have any sort order, and may not use limit or skip.

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

Adds a constraint that requires that a key's value matches a value in an object returned by a different Parse.Query.

Adds a constraint that requires that a key's value matches a Parse.Query constraint.

Adds a proximity based constraint for finding objects with key point values near the point given.

Adds a constraint to the query that requires a particular key's value to not be contained in the provided list of values.

Adds a constraint to the query that requires a particular key's value to be not equal to the provided value.

Add a constraint to the query that requires a particular key's coordinates that contains a ParseGeoPoint

Changes the read preference that the backend will use when performing the query to the database.

Iterates over each result of a query, calling a callback for each one. If the callback returns a promise, the iteration will not continue until that promise has been fulfilled. If the callback returns a rejected promise, then iteration will stop with that error. The items are processed in an unspecified order. The query may not have any sort order, and may not use limit or skip.

Restricts the fields of the returned Parse.Objects to include only the provided keys. If this is called multiple times, then all of the keys specified in each of the calls will be included.

Sets the number of results to skip before returning any results. This is useful for pagination. Default is to skip zero results.

Method to sort the full text search by text score

Adds a constraint for finding string values that start with a provided string. This query will use the backend index, so it will be fast even for large datasets.

Subscribe this query to get liveQuery updates

Returns a JSON representation of this query.

Sets the flag to include with response the total number of objects satisfying this query, despite limits/skip. Might be useful for pagination. Note that result of this query will be wrapped as an object with results: holding {ParseObject} array and count: integer holding total number

Adds a constraint to the query that requires a particular key's coordinates be contained within a given rectangular geographic bounding box.

Adds a proximity based constraint for finding objects with key point values near the point given and within the maximum distance given. Radius of earth used is 6371.0 kilometers.

Adds a proximity based constraint for finding objects with key point values near the point given and within the maximum distance given. Radius of earth used is 3958.8 miles.

Adds a constraint to the query that requires a particular key's coordinates be contained within and on the bounds of a given polygon. Supports closed and open (last point is connected to first) paths

Polygon must have at least 3 points

Adds a proximity based constraint for finding objects with key point values near the point given and within the maximum distance given.

Return a query with conditions from json, can be useful to send query from server side to client Not static, all query conditions was set before calling this method will be deleted. For example on the server side we have var query = new Parse.Query("className"); query.equalTo(key: value); query.limit(100); ... (others queries) Create JSON representation of Query Object var jsonFromServer = query.fromJSON();

On client side getting query: var query = new Parse.Query("className"); query.fromJSON(jsonFromServer);

and continue to query... query.skip(100).find().then(...);