From 6804dbe222ab952b825ae7b754d5c90340cbb8a5 Mon Sep 17 00:00:00 2001 From: Addison Elliott Date: Wed, 9 Aug 2017 09:24:52 -0500 Subject: [PATCH 01/12] Remove skip/limit limit doc from iOS Queries --- _includes/ios/queries.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/_includes/ios/queries.md b/_includes/ios/queries.md index 6fcc20ae3..10a720561 100644 --- a/_includes/ios/queries.md +++ b/_includes/ios/queries.md @@ -150,7 +150,7 @@ let predicate = NSPredicate(format:"playerName != 'Michael Yabuti' AND playerAge let query = PFQuery(className: "GameScore", predicate: predicate) -You can limit the number of results by setting `limit`. By default, results are limited to 100, but anything from 1 to 1000 is a valid limit: +You can limit the number of results by setting `limit`. By default, results are limited to 100. In the old Parse hosted backend, the maximum limit was 1000, but Parse Server removed that constraint: 

 query.limit = 10; // limit to at most 10 results
@@ -187,7 +187,7 @@ query.getFirstObjectInBackgroundWithBlock {
 }
-You can skip the first results by setting `skip`. This can be useful for pagination: +You can skip the first results by setting `skip`. In the old Parse hosted backend, the maximum skip value was 10,000, but Parse Server removed that constraint. This can be useful for pagination: 

 query.skip = 10; // skip the first 10 results
@@ -570,7 +570,7 @@ query.whereKey("post", equalTo: PFObject(withoutDataWithClassName: "Post", objec
 NSPredicate(format: "post = %@", PFObject(withoutDataWithClassName: "Post", objectId: "1zEcyElZ80"))
-If you want to retrieve objects where a field contains a `PFObject` that match a different query, you can use `whereKey:matchesQuery`. Note that the default limit of 100 and maximum limit of 1000 apply to the inner query as well, so with large data sets you may need to construct queries carefully to get the desired behavior. In order to find comments for posts with images, you can do: +If you want to retrieve objects where a field contains a `PFObject` that match a different query, you can use `whereKey:matchesQuery`. In order to find comments for posts with images, you can do: 

 // Using PFQuery
@@ -830,7 +830,7 @@ Query caching also works with PFQuery helpers including `getFirstObject` and `ge
 
 ## Counting Objects
 
-Caveat: Count queries are rate limited to a maximum of 160 requests per minute.  They can also return inaccurate results for classes with more than 1,000 objects.  Thus, it is preferable to architect your application to avoid this sort of count operation (by using counters, for example.)
+Note: In the old Parse hosted backend, count queries were rate limited to a maximum of 160 requests per minute. They also returned inaccurate results for classes with more than 1,000 objects. But, Parse Server has removed both constraints and can count objects well above 1,000.
 
 If you just need to count how many objects match a query, but you do not need to retrieve the objects that match, you can use `countObjects` instead of `findObjects`. For example, to count how many games have been played by a particular player:
 

From c89e06161ccb6724e77c4806eb5888ddeb4f7319 Mon Sep 17 00:00:00 2001
From: Addison Elliott 
Date: Wed, 9 Aug 2017 09:38:27 -0500
Subject: [PATCH 02/12] Remove skip/limit limit doc from Performance

---
 _includes/common/performance.md | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/_includes/common/performance.md b/_includes/common/performance.md
index 077ee22d5..51f302943 100644
--- a/_includes/common/performance.md
+++ b/_includes/common/performance.md
@@ -694,7 +694,7 @@ Most of the use cases around using regular expressions involve implementing sear
 
 Writing restrictive queries allows you to return only the data that the client needs. This is critical in a mobile environment were data usage can be limited and network connectivity unreliable. You also want your mobile app to appear responsive and this is directly affected by the objects you send back to the client. The [Querying section](#queries) shows the types of constraints you can add to your existing queries to limit the data returned. When adding constraints, you want to pay attention and design efficient queries.
 
-You can limit the number of query results returned. The limit is 100 by default but anything from 1 to 1000 is a valid limit:
+You can use skip and limit to page through results and load the data as is needed. The query limit is 100 by default:
 
 ```javascript
 query.limit(10); // limit to at most 10 results
@@ -996,7 +996,7 @@ If later on, you need to modify the underlying data model, your client call can
 
 ## Avoid Count Operations
 
-For classes with over 1,000 objects, count operations are limited by timeouts. Thus, it is preferable to architect your application to avoid this count operation.
+When counting objects frequently, consider storing a count variable in the database that is incremented each time an object is added.
 
 Suppose you are displaying movie information in your app and your data model consists of a Movie class and a Review class that contains a pointer to the corresponding movie. You might want to display the review count for each movie on the top-level navigation screen using a query like this:
 
@@ -1288,17 +1288,13 @@ There are some limits in place to ensure the API can provide the data you need i
 
 **Queries**
 
-* Queries return 100 objects by default. Use the `limit` parameter to change this, up to a value of 1,000.
+* Queries return 100 objects by default. Use the `limit` parameter to change this.
 * Queries can only return up to 1,000 objects in a single result set. This includes any resolved pointers. You can use `skip` and `limit` to page through results.
-* The maximum value accepted by `skip` is 10,000. If you need to get more objects, we recommend sorting the results and then using a constraint on the sort column to filter out the first 10,000 results. You will then be able to continue paging through results starting from a `skip` value of 0. For example, you can sort your results by `createdAt ASC` and then filter out any objects older than the `createdAt` value of the 10,000th object when starting again from 0.
-* Alternatively, you may use the `each()` method in the JavaScript SDK to page through all objects that match the query.
 * Skips and limits can only be used on the outer query.
-* You may increase the limit of a inner query to 1,000, but skip cannot be used to get more results past the first 1,000.
 * Constraints that collide with each other will result in only one of the constraint being applied. An example of this would be two `equalTo` constraints over the same key with two different values, which contradicts itself (perhaps you're looking for 'contains').
 * No geo-queries inside compound OR queries.
 * Using `$exists: false` is not advised.
 * The `each` query method in the JavaScript SDK cannot be used in conjunction with queries using geo-point constraints.
-* A maximum of 500,000 objects will be scanned per query. If your constraints do not successfully limit the scope of the search, this can result in queries with incomplete results.  
 * A `containsAll` query constraint can only take up to 9 items in the comparison array.
 
 **Push Notifications**

From 8fb6bf549eb3ee03056b6a0f7e272a789f167d9c Mon Sep 17 00:00:00 2001
From: Addison Elliott 
Date: Wed, 9 Aug 2017 09:40:21 -0500
Subject: [PATCH 03/12] Remove limit maximum constraint doc

---
 _includes/common/performance.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/_includes/common/performance.md b/_includes/common/performance.md
index 51f302943..8a9aa8803 100644
--- a/_includes/common/performance.md
+++ b/_includes/common/performance.md
@@ -1289,7 +1289,6 @@ There are some limits in place to ensure the API can provide the data you need i
 **Queries**
 
 * Queries return 100 objects by default. Use the `limit` parameter to change this.
-* Queries can only return up to 1,000 objects in a single result set. This includes any resolved pointers. You can use `skip` and `limit` to page through results.
 * Skips and limits can only be used on the outer query.
 * Constraints that collide with each other will result in only one of the constraint being applied. An example of this would be two `equalTo` constraints over the same key with two different values, which contradicts itself (perhaps you're looking for 'contains').
 * No geo-queries inside compound OR queries.

From 301aef68903e79abe676ad790a19d9fabd9e1e47 Mon Sep 17 00:00:00 2001
From: Addison Elliott 
Date: Wed, 9 Aug 2017 09:44:13 -0500
Subject: [PATCH 04/12] Alter language for Avoid Counting Objects section

---
 _includes/common/performance.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/_includes/common/performance.md b/_includes/common/performance.md
index 8a9aa8803..39d644925 100644
--- a/_includes/common/performance.md
+++ b/_includes/common/performance.md
@@ -996,7 +996,7 @@ If later on, you need to modify the underlying data model, your client call can
 
 ## Avoid Count Operations
 
-When counting objects frequently, consider storing a count variable in the database that is incremented each time an object is added.
+When counting objects frequently, instead consider storing a count variable in the database that is incremented each time an object is added. Then, the count can quickly be retrieved by simply retrieving the variable stored.
 
 Suppose you are displaying movie information in your app and your data model consists of a Movie class and a Review class that contains a pointer to the corresponding movie. You might want to display the review count for each movie on the top-level navigation screen using a query like this:
 

From fc35393c3e4508f6f1c7293e3d619b834fc151a3 Mon Sep 17 00:00:00 2001
From: Addison Elliott 
Date: Wed, 9 Aug 2017 09:47:27 -0500
Subject: [PATCH 05/12] Add comma to 1000, better readability

---
 _includes/ios/queries.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/_includes/ios/queries.md b/_includes/ios/queries.md
index 10a720561..9d209689a 100644
--- a/_includes/ios/queries.md
+++ b/_includes/ios/queries.md
@@ -150,7 +150,7 @@ let predicate = NSPredicate(format:"playerName != 'Michael Yabuti' AND playerAge
 let query = PFQuery(className: "GameScore", predicate: predicate)
-You can limit the number of results by setting `limit`. By default, results are limited to 100. In the old Parse hosted backend, the maximum limit was 1000, but Parse Server removed that constraint: +You can limit the number of results by setting `limit`. By default, results are limited to 100. In the old Parse hosted backend, the maximum limit was 1,000, but Parse Server removed that constraint: 

 query.limit = 10; // limit to at most 10 results

From 511225e0151350327526845e31406135f225d20e Mon Sep 17 00:00:00 2001
From: Addison Elliott 
Date: Wed, 9 Aug 2017 09:54:52 -0500
Subject: [PATCH 06/12] Remove skip/limit limit doc from Arduino Queries

---
 _includes/arduino/queries.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/_includes/arduino/queries.md b/_includes/arduino/queries.md
index 4d6009ab4..f7363de64 100644
--- a/_includes/arduino/queries.md
+++ b/_includes/arduino/queries.md
@@ -36,13 +36,13 @@ query.whereEqualTo("leverDown", true);
 query.whereEqualTo("temperature", 100.0);
 ```
 
-You can limit the number of results by setting a limit. By default, results are limited to 100, but anything from 1 to 1000 is a valid limit:
+You can limit the number of results by setting a limit. By default, results are limited to 100. In the old Parse hosted backend, the maximum limit was 1,000, but Parse Server removed that constraint:
 
 ```cpp
 query.setLimit(10);
 ```
 
-You can skip the first results by setting `skip`. This can be useful for pagination:
+You can skip the first results by setting `skip`. In the old Parse hosted backend, the maximum skip value was 10,000, but Parse Server removed that constraint. This can be useful for pagination:
 
 ```cpp
 query.setSkip(10);

From 6c25d9004fa88d665127ba660960dba300908030 Mon Sep 17 00:00:00 2001
From: Addison Elliott 
Date: Wed, 9 Aug 2017 09:56:32 -0500
Subject: [PATCH 07/12] Remove skip/limit limit doc from Android Queries

---
 _includes/android/queries.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/_includes/android/queries.md b/_includes/android/queries.md
index eb9c75415..a19224c28 100644
--- a/_includes/android/queries.md
+++ b/_includes/android/queries.md
@@ -39,7 +39,7 @@ query.whereNotEqualTo("playerName", "Michael Yabuti");
 query.whereGreaterThan("playerAge", 18);
 ```
 
-You can limit the number of results with `setLimit`. By default, results are limited to 100, but anything from 1 to 1000 is a valid limit:
+You can limit the number of results with `setLimit`. By default, results are limited to 100. In the old Parse hosted backend, the maximum limit was 1,000, but Parse Server removed that constraint:
 
 ```java
 query.setLimit(10); // limit to at most 10 results
@@ -61,7 +61,7 @@ query.getFirstInBackground(new GetCallback() {
 });
 ```
 
-You can skip the first results with `setSkip`. This can be useful for pagination:
+You can skip the first results with `setSkip`. In the old Parse hosted backend, the maximum skip value was 10,000, but Parse Server removed that constraint. This can be useful for pagination:
 
 ```java
 query.setSkip(10); // skip the first 10 results
@@ -227,7 +227,7 @@ query.findInBackground(new FindCallback() {
 });
 ```
 
-If you want to retrieve objects where a field contains a `ParseObject` that matches a different query, you can use `whereMatchesQuery`. Note that the default limit of 100 and maximum limit of 1000 apply to the inner query as well, so with large data sets you may need to construct queries carefully to get the desired behavior. In order to find comments for posts containing images, you can do:
+If you want to retrieve objects where a field contains a `ParseObject` that matches a different query, you can use `whereMatchesQuery`. In order to find comments for posts containing images, you can do:
 
 ```java
 ParseQuery innerQuery = ParseQuery.getQuery("Post");
@@ -387,7 +387,7 @@ Query caching also works with ParseQuery helpers including `getFirst()` and `get
 
 ## Counting Objects
 
-Caveat: Count queries are rate limited to a maximum of 160 requests per minute.  They can also return inaccurate results for classes with more than 1,000 objects.  Thus, it is preferable to architect your application to avoid this sort of count operation (by using counters, for example.)
+Note: In the old Parse hosted backend, count queries were rate limited to a maximum of 160 requests per minute. They also returned inaccurate results for classes with more than 1,000 objects. But, Parse Server has removed both constraints and can count objects well above 1,000.
 
 If you just need to count how many objects match a query, but you do not need to retrieve all the objects that match, you can use `count` instead of `find`. For example, to count how many games have been played by a particular player:
 

From c1aa738397f5fe81b6fab8722de41eed0d767acc Mon Sep 17 00:00:00 2001
From: Addison Elliott 
Date: Wed, 9 Aug 2017 09:58:59 -0500
Subject: [PATCH 08/12] Remove skip/limit limit doc from DotNet Queries

---
 _includes/dotnet/queries.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/_includes/dotnet/queries.md b/_includes/dotnet/queries.md
index d496b8ef1..c64e64d9b 100644
--- a/_includes/dotnet/queries.md
+++ b/_includes/dotnet/queries.md
@@ -56,7 +56,7 @@ var query = ParseObject.GetQuery("GameScore")
     .WhereGreaterThan("playerAge", 18);
 ```
 
-You can limit the number of results by calling `Limit`. By default, results are limited to 100, but anything from 1 to 1000 is a valid limit:
+You can limit the number of results by calling `Limit`. By default, results are limited to 100. In the old Parse hosted backend, the maximum limit was 1,000, but Parse Server removed that constraint:
 
 ```cs
 query = query.Limit(10); // limit to at most 10 results
@@ -76,7 +76,7 @@ var query = ParseObject.GetQuery("GameScore")
 ParseObject obj = await query.FirstAsync();
 ```
 
-You can skip the first results by calling `Skip`. This can be useful for pagination:
+You can skip the first results by calling `Skip`. In the old Parse hosted backend, the maximum skip value was 10,000, but Parse Server removed that constraint. This can be useful for pagination:
 
 ```cs
 query = query.Skip(10); // skip the first 10 results
@@ -285,7 +285,7 @@ var query = ParseObject.GetQuery("Comment")
     .WhereEqualTo("post", ParseObject.CreateWithoutData("Post", "1zEcyElZ80"));
 ```
 
-If you want to retrieve objects where a field contains a `ParseObject` that matches a different query, you can use `WhereMatchesQuery` or a `join` LINQ query. Note that the default limit of 100 and maximum limit of 1000 apply to the inner query as well, so with large data sets you may need to construct queries carefully to get the desired behavior. In order to find comments for posts with images, you can do:
+If you want to retrieve objects where a field contains a `ParseObject` that matches a different query, you can use `WhereMatchesQuery` or a `join` LINQ query. In order to find comments for posts with images, you can do:
 
 ```cs
 var imagePosts = from post in ParseObject.GetQuery("Post")
@@ -388,7 +388,7 @@ You can issue a query with multiple fields included by calling `Include` multipl
 
 ## Counting Objects
 
-Caveat: Count queries are rate limited to a maximum of 160 requests per minute.  They can also return inaccurate results for classes with more than 1,000 objects.  Thus, it is preferable to architect your application to avoid this sort of count operation (by using counters, for example.)
+Note: In the old Parse hosted backend, count queries were rate limited to a maximum of 160 requests per minute. They also returned inaccurate results for classes with more than 1,000 objects. But, Parse Server has removed both constraints and can count objects well above 1,000.
 
 If you just need to count how many objects match a query, but you do not need to retrieve the objects that match, you can use `CountAsync` instead of `FindAsync`. For example, to count how many games have been played by a particular player:
 

From 2a2f3835291527c74d72262c1e974a060b424e41 Mon Sep 17 00:00:00 2001
From: Addison Elliott 
Date: Wed, 9 Aug 2017 10:00:46 -0500
Subject: [PATCH 09/12] Remove skip/limit limit doc from JS Queries

---
 _includes/js/queries.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/_includes/js/queries.md b/_includes/js/queries.md
index e589780ff..2d7831f6a 100644
--- a/_includes/js/queries.md
+++ b/_includes/js/queries.md
@@ -42,7 +42,7 @@ query.notEqualTo("playerName", "Michael Yabuti");
 query.greaterThan("playerAge", 18);
-You can limit the number of results by setting `limit`. By default, results are limited to 100, but anything from 1 to 1000 is a valid limit: +You can limit the number of results by setting `limit`. By default, results are limited to 100. In the old Parse hosted backend, the maximum limit was 1,000, but Parse Server removed that constraint: 

 query.limit(10); // limit to at most 10 results
@@ -64,7 +64,7 @@ query.first({
 });
-You can skip the first results by setting `skip`. This can be useful for pagination: +You can skip the first results by setting `skip`. In the old Parse hosted backend, the maximum skip value was 10,000, but Parse Server removed that constraint. This can be useful for pagination: 

 query.skip(10); // skip the first 10 results
@@ -221,7 +221,7 @@ query.find({
 });
-If you want to retrieve objects where a field contains a `Parse.Object` that matches a different query, you can use `matchesQuery`. Note that the default limit of 100 and maximum limit of 1000 apply to the inner query as well, so with large data sets you may need to construct queries carefully to get the desired behavior. In order to find comments for posts containing images, you can do: +If you want to retrieve objects where a field contains a `Parse.Object` that matches a different query, you can use `matchesQuery`. In order to find comments for posts containing images, you can do: 

 var Post = Parse.Object.extend("Post");
@@ -297,7 +297,7 @@ You can issue a query with multiple fields included by calling `include` multipl
 
 ## Counting Objects
 
-Caveat: Count queries are rate limited to a maximum of 160 requests per minute.  They can also return inaccurate results for classes with more than 1,000 objects.  Thus, it is preferable to architect your application to avoid this sort of count operation (by using counters, for example.)
+Note: In the old Parse hosted backend, count queries were rate limited to a maximum of 160 requests per minute. They also returned inaccurate results for classes with more than 1,000 objects. But, Parse Server has removed both constraints and can count objects well above 1,000.
 
 If you just need to count how many objects match a query, but you do not need to retrieve all the objects that match, you can use `count` instead of `find`. For example, to count how many games have been played by a particular player:
 

From f4a3aaa1980ff853e23db94974dffbfcd1c1878b Mon Sep 17 00:00:00 2001
From: Addison Elliott 
Date: Wed, 9 Aug 2017 10:02:48 -0500
Subject: [PATCH 10/12] Remove skip/limit limit doc from PHP Queries

---
 _includes/php/queries.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/_includes/php/queries.md b/_includes/php/queries.md
index fc6242a57..cf0c7b52b 100644
--- a/_includes/php/queries.md
+++ b/_includes/php/queries.md
@@ -35,7 +35,7 @@ $query->notEqualTo("playerName", "Michael Yabuti");
 $query->greaterThan("playerAge", 18);
-You can limit the number of results by setting `limit`. By default, results are limited to 100, but anything from 1 to 1000 is a valid limit: +You can limit the number of results by setting `limit`. By default, results are limited to 100. In the old Parse hosted backend, the maximum limit was 1,000, but Parse Server removed that constraint: 

 $query->limit(10); // limit to at most 10 results
@@ -49,7 +49,7 @@ $query->equalTo("playerEmail", "dstemkoski@example.com");
 $object = $query->first();
-You can skip the first results by setting `skip`. This can be useful for pagination, though it is limited to a maximum of ten thousand: +You can skip the first results by setting `skip`. In the old Parse hosted backend, the maximum skip value was 10,000, but Parse Server removed that constraint. This can be useful for pagination: 

 $query->skip(10); // skip the first 10 results
@@ -214,7 +214,7 @@ $comments = $query->find();
 // comments now contains the comments for myPost
-If you want to retrieve objects where a field contains a `ParseObject` that matches a different query, you can use `matchesQuery`. Note that the default limit of 100 and maximum limit of 1000 apply to the inner query as well, so with large data sets you may need to construct queries carefully to get the desired behavior. In order to find comments for posts containing images, you can do: +If you want to retrieve objects where a field contains a `ParseObject` that matches a different query, you can use `matchesQuery`. In order to find comments for posts containing images, you can do: 

 $innerQuery = new ParseQuery("Post");
@@ -276,7 +276,7 @@ You can issue a query with multiple fields included by calling `includeKey` mult
 
 ## Counting Objects
 
-Caveat: Count queries are rate limited to a maximum of 160 requests per minute.  They can also return inaccurate results for classes with more than 1,000 objects.  Thus, it is preferable to architect your application to avoid this sort of count operation (by using counters, for example.)
+Note: In the old Parse hosted backend, count queries were rate limited to a maximum of 160 requests per minute. They also returned inaccurate results for classes with more than 1,000 objects. But, Parse Server has removed both constraints and can count objects well above 1,000.
 
 If you just need to count how many objects match a query, but you do not need to retrieve all the objects that match, you can use `count` instead of `find`. For example, to count how many games have been played by a particular player:
 

From 0701863ab4b3298fc9bc2728106296d757bf079f Mon Sep 17 00:00:00 2001
From: Addison Elliott 
Date: Wed, 9 Aug 2017 10:05:11 -0500
Subject: [PATCH 11/12] Remove skip/limit limit doc from REST Queries

---
 _includes/rest/queries.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/_includes/rest/queries.md b/_includes/rest/queries.md
index 5e7757aac..16d6e2bcf 100644
--- a/_includes/rest/queries.md
+++ b/_includes/rest/queries.md
@@ -363,7 +363,7 @@ result = json.loads(connection.getresponse().read())
 print result
-You can use the `limit` and `skip` parameters for pagination. `limit` defaults to 100, but anything from 1 to 1000 is a valid limit. Thus, to retrieve 200 objects after skipping the first 400: +You can use the `limit` and `skip` parameters for pagination.`limit` defaults to 100. In the old Parse hosted backend, the maximum limit was 1,000, but Parse Server removed that constraint. Thus, to retrieve 200 objects after skipping the first 400: 

 curl -X GET \
@@ -588,7 +588,7 @@ result = json.loads(connection.getresponse().read())
 print result
-If you want to retrieve objects where a field contains an object that matches another query, you can use the `$inQuery` operator. Note that the default limit of 100 and maximum limit of 1000 apply to the inner query as well, so with large data sets you may need to construct queries carefully to get the desired behavior. For example, imagine you have Post class and a Comment class, where each Comment has a pointer to its parent Post. You can find comments on posts with images by doing: +If you want to retrieve objects where a field contains an object that matches another query, you can use the `$inQuery` operator. For example, imagine you have Post class and a Comment class, where each Comment has a pointer to its parent Post. You can find comments on posts with images by doing: 

 curl -X GET \
@@ -766,7 +766,7 @@ You can issue a query with multiple fields included by passing a comma-separated
 
 ## Counting Objects
 
-Caveat: Count queries are rate limited to a maximum of 160 requests per minute.  They can also return inaccurate results for classes with more than 1,000 objects.  Thus, it is preferable to architect your application to avoid this sort of count operation (by using counters, for example.)
+Note: In the old Parse hosted backend, count queries were rate limited to a maximum of 160 requests per minute. They also returned inaccurate results for classes with more than 1,000 objects. But, Parse Server has removed both constraints and can count objects well above 1,000.
 
 If you are limiting your query, or if there are a very large number of results, and you want to know how many total results there are without returning them all, you can use the `count` parameter. For example, if you only care about the number of games played by a particular player:
 

From 149611ad00b9c7e317a2e53dd17ba0ee95ca6658 Mon Sep 17 00:00:00 2001
From: Addison Elliott 
Date: Wed, 9 Aug 2017 10:06:32 -0500
Subject: [PATCH 12/12] Remove skip/limit limit doc from Unity Queries

---
 _includes/unity/queries.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/_includes/unity/queries.md b/_includes/unity/queries.md
index 6226ad600..35b1f5199 100644
--- a/_includes/unity/queries.md
+++ b/_includes/unity/queries.md
@@ -36,7 +36,7 @@ var query = ParseObject.GetQuery("GameScore")
     .WhereGreaterThan("playerAge", 18);
 ```
 
-You can limit the number of results by calling `Limit`. By default, results are limited to 100, but anything from 1 to 1000 is a valid limit:
+You can limit the number of results by calling `Limit`. By default, results are limited to 100. In the old Parse hosted backend, the maximum limit was 1,000, but Parse Server removed that constraint:
 
 ```cs
 query = query.Limit(10); // limit to at most 10 results
@@ -53,7 +53,7 @@ query.FirstAsync().ContinueWith(t =>
 });
 ```
 
-You can skip the first results by calling `Skip`. This can be useful for pagination:
+You can skip the first results by calling `Skip`. In the old Parse hosted backend, the maximum skip value was 10,000, but Parse Server removed that constraint. This can be useful for pagination:
 
 ```cs
 query = query.Skip(10); // skip the first 10 results
@@ -180,7 +180,7 @@ var query = ParseObject.GetQuery("Comment")
     .WhereEqualTo("post", ParseObject.CreateWithoutData("Post", "1zEcyElZ80"));
 ```
 
-If you want to retrieve objects where a field contains a `ParseObject` that matches a different query, you can use `WhereMatchesQuery`. Note that the default limit of 100 and maximum limit of 1000 apply to the inner query as well, so with large data sets you may need to construct queries carefully to get the desired behavior. In order to find comments for posts with images, you can do:
+If you want to retrieve objects where a field contains a `ParseObject` that matches a different query, you can use `WhereMatchesQuery`. In order to find comments for posts with images, you can do:
 
 ```cs
 var imagePosts = ParseObject.GetQuery("Post")
@@ -250,7 +250,7 @@ You can issue a query with multiple fields included by calling `Include` multipl
 
 ## Counting Objects
 
-Caveat: Count queries are rate limited to a maximum of 160 requests per minute.  They can also return inaccurate results for classes with more than 1,000 objects.  Thus, it is preferable to architect your application to avoid this sort of count operation (by using counters, for example.)
+Note: In the old Parse hosted backend, count queries were rate limited to a maximum of 160 requests per minute. They also returned inaccurate results for classes with more than 1,000 objects. But, Parse Server has removed both constraints and can count objects well above 1,000.
 
 If you just need to count how many objects match a query, but you do not need to retrieve the objects that match, you can use `CountAsync` instead of `FindAsync`. For example, to count how many games have been played by a particular player: