retrieve unique values for key from parse.com when class has > 1000 objects

Question

In parse I have a class named "TestScore". Each object has a key named "quizName".

I need to get an array of unique "quizName" values. I wrote the below which queries the "TestClass" and loops through the results looking for unique "quizName" values.

At first seemed to do the job. But then I realized that the maximum number of returned objects is 1000. Soon there will be more than 1000 objects stored which means that this method will not guarantee that I end up will all values.

function loadTests(){
    //create an array to hold each unique test name as we find them
    var uniqueEntries = [];

    //query parse to return TestScore objects
    var TestScore = Parse.Object.extend("TestScore");
    var query = new Parse.Query(TestScore);
    query.limit(1000)  //added this after realizing that the default query limit is only 100 
    query.find({
      success: function(testScore) {
          $(testScore).each(function(index, score) {

             //here I loop though all of the returned objects looking at the "quizName" for each
             if($.inArray(score.get("quizName"), uniqueEntries) === -1) {

               //if the quiz name is not already in the "uniqueEntries" array, I add it to the array
                uniqueEntries.push(score.get("quizName"));
             }
          });
          //do stuff with quiznames here...., add them as options in select boxes mostly
      }
    });
}

I looked at {Parse.Query} notContainedIn(key, values) which looks promising but cant figure out if I can add values to the array as I find them. It seems like I would have to have an array to start with (defeating the whole point.)

This part of the docs "{Parse.Query} Returns the query, so you can chain this call." makes me think I might be able to chain queries together to get what I need, but that doesn't seem very efficient.

How can I retrieve unique values for key "quizName" when my class has > 1000 objects?

Answer 1

I eventually found a tutorial online that I was able to modify and came up with the below. This effectively sets the return limit to 10,000 instead of 1,000 and allows setting several different parameters for the query.

My changes could surely be written better, maybe as an options object or similar but it works for my needs.

You can see a working demo here

function getStuff(){
    // here we will setup and call our helper functions with callbacks to handle the results
    var scheme =['SOTest',true]; // return all objects with value `true` in the `SOTest` column
    // var scheme =['descending','createdAt']; // return all objects with sort order applied
    // var scheme ='';  // or just return all objects
    // see `findChunk()` below for more info
    var Remark = Parse.Object.extend("Remark");
    schemePromise(Remark, scheme).done(function (all) {

        console.log('Found ' + all.length+' Remarks');

        $.each( all, function(i, obj){
            $('#test').append(obj.get('Remark') +'<br>');

        });
    })
        .fail(function (error) {
            console.log("error:  " + JSON.stringify(error));
    });

}


getStuff(); // call our function

// helper functions used to get around parse's 1000 query limit
// raises the limit to 10,000 by using promises 
function findChunk(model, scheme, allData) {
    // if `scheme` was an empty string, convert to an array
    // this is the default and returns all objects in the called class
    if(scheme==''){ ['scheme',''] };
     // will return a promise
    var limit = 1000;
    var skip = allData.length;
    var findPromise = $.Deferred();
    var query = new Parse.Query(model);
    // to get all objects from the queried Class then sort them by some column
    // pass `scheme` as an array like [ sort method, column to sort ] 
    if (scheme[0]=='descending') query.descending(scheme[1]);
    else if (scheme[0]=='ascending') query.ascending(scheme[1]);
    // to limt results to objects that have a certain value in a specific column
    // pass `scheme` as an array like [ column name, value ] 
    else query.equalTo(scheme[0], scheme[1]);
    // more options can easily be built in here using `scheme`
    query
        .limit(limit)
        .skip(skip)
        .find()
        .then(function (results) {
        findPromise.resolve(allData.concat(results), !results.length);
    }, function (results) {
        findPromise.reject(error);
    });
    return findPromise.promise();
}
function schemePromise(model, scheme, allResults, allPromise) {
    // find a scheme at a time
    var promise = allPromise || $.Deferred();
    findChunk(model, scheme, allResults || [])
        .done(function (results, allOver) {
        if (allOver) {
            // we are done
            promise.resolve(results);
        } else {
            // may be more
            schemePromise(model, scheme, results, promise);
        }
    })
        .fail(function (error) {
        promise.reject(error);
    });
    return promise.promise();
}   

Answer 2

I'm sure you're long past this by now, but only way I know of to do it is to use one query after another by using a .skip(#) value for each query. So get 1000, then query again with .skip(1000), concatenate the items from the first list and second, then query again with .skip(2000), etc...

Be aware that I think there's a limit on skip values of 10,000. Don't take my word on that, just pointing you to something that I think is right that you should confirm if you think it applies to your situation.