Jak odzyskać więcej niż 1000 wierszy z Parse.com?

Question

Używam Parse do pobierania danych dla widoku listy. Niestety domyślnie ograniczają żądania do 100 do 1000 maks. Mam ponad 1000 w mojej klasie. Znalazłem link w Internecie, który pokazuje sposób na to, aby zrobić to na iOS, ale jak to zrobić w systemie Android? Web Link

Obecnie jestem dodając wszystkie dane w ArrayList w pętli, dopóki wszystkie elementy są kompletne (100), a następnie dodanie ich do listy

Answer 1

I zorientowali się, jak osiągnąć swój cel:

stwierdzenie Globalna zmienna

private static List<ParseObject>allObjects = new ArrayList<ParseObject>(); 

Utwórz kwerendę

final ParseQuery parseQuery = new ParseQuery("Objects"); 
parseQuery.setLimit(1000); 
parseQuery.findInBackground(getAllObjects()); 

oddzwaniania Query

int skip=0; 
FindCallback getAllObjects(){ 
    return new FindCallback(){ 
     public void done(List<ParseObject> objects, ParseException e) { 
      if (e == null) { 

       allObjects.addAll(objects); 
       int limit =1000; 
       if (objects.size() == limit){ 
        skip = skip + limit; 
        ParseQuery query = new ParseQuery("Objects"); 
        query.setSkip(skip); 
        query.setLimit(limit); 
        query.findInBackground(getAllObjects()); 
       } 
       //We have a full PokeDex 
       else { 
        //USE FULL DATA AS INTENDED 
       } 
     } 
    }; 
} 

Answer 2

Można to osiągnąć za pomocą CloudCode ... Marka funkcję niestandardową ty może wywołać, że wyliczy całą kolekcję i zbuduje odpowiedź z tego, ale mądrzejszym wyborem będzie paginacja twoich żądań i pobranie rekordów 1000 (lub nawet mniej) naraz, dodając je do listy dynamicznie w razie potrzeby.

Answer 3

Oto JavaScript wersja bez obietnic ..

Są to zmienne globalne (zbiory nie są wymagane, tylko zły nawyk kopalni) ..

///create a collection of cool things and instantiate it (globally) 
    var CoolCollection = Parse.Collection.extend({ 
     model: CoolThing 
    }), coolCollection = new CoolCollection(); 

Jest to funkcja "zapętlania", która daje wyniki.

//recursive call, initial loopCount is 0 (we haven't looped yet) 
function getAllRecords(loopCount){ 

    ///set your record limit 
    var limit = 1000; 

    ///create your eggstra-special query 
    new Parse.Query(CoolThings) 
      .limit(limit) 
      .skip(limit * loopCount) //<-important 
      .find({ 
      success: function (results) { 
       if(results.length > 0){ 

        //we do stuff in here like "add items to a collection of cool things" 
        for(var j=0; j < results.length; j++){ 
         coolCollection.add(results[j]); 
        } 

        loopCount++; //<--increment our loop because we are not done 

        getAllRecords(loopCount); //<--recurse 
       } 
       else 
       { 
        //our query has run out of steam, this else{} will be called one time only 
        coolCollection.each(function(coolThing){ 
         //do something awesome with each of your cool things 
        }); 
       } 
      }, 
      error: function (error) { 
       //badness with the find 
      } 
     }); 
} 

ten sposób można nazwać (czy można zrobić to inne sposoby):

getAllRecords(0); 

Answer 4

W C# Używam tego rekurencji:

private static async Task GetAll(int count = 0, int limit = 1000) 
{ 
    if (count * limit != list.Count) return; 
    var res = await ParseObject.GetQuery("Row").Limit(limit).Skip(list.Count).FindAsync(); 
    res.ToList().ForEach(x => list.Add(x)); 
    await GetAll(++count); 
} 

JS wersja:

function getAll(list) { 
    new Parse.Query(Row).limit(1000).skip(list.length).find().then(function (result) { 
     list = list.concat(result); 
     if (result.length != 1000) { 
      //do here something with the list... 
      return; 
     } 

     getAll(list); 
    }); 
} 

Użycie: GetAll() w języku C# i getAll([]) w JS.

Przechowuję wszystkie wiersze z klasy w list. W każdym żądaniu otrzymuję 1000 wierszy i pomijam bieżący rozmiar list. Rekursja zatrzymuje się, gdy bieżąca liczba wyeksportowanych wierszy różni się od oczekiwanej.

Answer 5

YAS (Jeszcze inne rozwiązanie!) Używanie async() i await() w javascript.

async parseFetchAll(collected = []) { 
    let query = new Parse.Query(GameScore); 
    const limit = 1000; 

    query.limit(limit); 
    query.skip(collected.length); 

    const results = await query.find(); 

    if(results.length === limit) { 
    return await parseFetchAll([ ...collected, ...results ]); 
    } else { 
    return collected.concat(results); 
    } 

} 

Answer 6

Swift 3 przykład:

var users = [String]() 
var payments = [String]() 
///set your record limit 
let limit = 29 
//recursive call, initial loopCount is 0 (we haven't looped yet) 
func loadAllPaymentDetails(_ loopCount: Int){ 
    ///create your NEW eggstra-special query 
    let paymentsQuery = Payments.query() 
    paymentsQuery?.limit = limit 
    paymentsQuery?.skip = limit*loopCount 
    paymentsQuery?.findObjectsInBackground(block: { (objects, error) in 
     if let objects = objects { 
      //print(#file.getClass()," ",#function," loopcount: ",loopCount,"  #ReturnedObjects: ", objects.count) 
      if objects.count > 0 { 
       //print(#function, " no. of objects :", objects.count) 
       for paymentsObject in objects { 
        let user = paymentsObject[Utils.name] as! String 
        let amount = paymentsObject[Utils.amount] as! String 
        self.users.append(user) 
        self.payments.append(amount) 
       } 
       //recurse our loop with increment because we are not done 
       self.loadAllPaymentDetails(loopCount + 1); //<--recurse 
      }else { 
       //our query has run out of steam, this else{} will be called one time only 
       //if the Table had been initially empty, lets inform the user: 
       if self.users.count == 1 { 
        Utils.createAlert(self, title: "No Payment has been made yet", message: "Please Encourage Users to make some Payments", buttonTitle: "Ok") 
       }else { 
        self.tableView.reloadData() 
       } 
      } 
     }else if error != nil { 
      print(error!) 
     }else { 
      print("Unknown Error") 
     } 
    }) 
} 

adaptacja użytkownika @ deLux_247 przykładzie.