Java ParseQuery.setSkip方法代码示例

import com.parse.ParseQuery; //导入方法依赖的package包/类
/**
 * Finds all {@link ParseObject}s from given {@link ParseQuery}.
 *
 * @param parseQuery parse query to use for querying objects
 * @return {@link List} with {@link ParseObject}s returned by given {@link ParseQuery}.
 *         Empty list in case of no results, never {@code null}.
 * @throws ParseException
 */
@NonNull
private List<T> findAll(ParseQuery<T> parseQuery) throws ParseException {
    int skip = 0;
    List<T> allObjects = new LinkedList<T>();
    parseQuery.setSkip(skip).setLimit(QUERY_LIMIT);

    boolean hasMore = true;
    while (hasMore) {
        List<T> foundObjects = parseQuery.find();
        allObjects.addAll(foundObjects);

        // Incrementing skip
        skip += QUERY_LIMIT;
        parseQuery.setSkip(skip);

        // If we have loaded as many objects as limit,
        // there might be more objects to load
        hasMore = foundObjects.size() == QUERY_LIMIT;
    }

    return allObjects;
}
 

import com.parse.ParseQuery; //导入方法依赖的package包/类
/**
 *  Limit 10000 by skip
 */
@NonNull
@CheckReturnValue
public static <R extends ParseObject> Observable<R> all(@NonNull final ParseQuery<R> query, int count) {
    final int limit = 1000; // limit limitation
    query.setSkip(0);
    query.setLimit(limit);
    Observable<R> find = find(query);
    for (int i = limit; i < count; i+= limit) {
        if (i >= 10000) break; // skip limitation
        query.setSkip(i);
        query.setLimit(limit);
        find.concatWith(find(query));
    }
    return find.distinct(o -> o.getObjectId());
}
 

import com.parse.ParseQuery; //导入方法依赖的package包/类
public void loadMoreData(Integer currentCount){
    if(!isUpdating){
        notifyUpdateStart();
        ParseQuery<SnackEntry> query = ParseQuery.getQuery(SnackEntry.class);
        query.orderByDescending("createdAt");
        query.whereEqualTo("owner", targetUser);
        query.setLimit(10);
        query.setSkip(currentCount);
        query.findInBackground(new FindCallback<SnackEntry>() {
            @Override
            public void done(List<SnackEntry> moreSnacks, ParseException e) {
                if (e == null) {
                    snacks.addAll(moreSnacks);
                }

                notifyUpdateComplete(e);
            }
        });
    }
}
 

import com.parse.ParseQuery; //导入方法依赖的package包/类
public List<Anime> getAnimeList(int page) {
    ArrayList<Anime> animeList = new ArrayList<>();
    try {
        ParseQuery<AnimeRecord> query = AnimeRecord.getQuery();
        query.setSkip((page-1) * 100);
        for (AnimeRecord record : query.find()) {
            Anime anime = AnimeRecord.toAnime(record);
            if (anime != null)
                animeList.add(anime);
        }
    } catch (ParseException e) {
        WriteLog.appendLogException(TAG, "getAnimeList failed", e);
    }
    return animeList;
}
 

import com.parse.ParseQuery; //导入方法依赖的package包/类
/**
 * Fetches a full list of messages between two users.
 *
 * @param user1 The first user
 * @param user2 The second user
 * @param callback The callback to invoke upon completion.
 */
private void fetchMessages(ParseUser user1, ParseUser user2, int limit, int skip, final FindCallback<Message> callback) {
    List<ParseQuery<Message>> orQueries = new ArrayList<>();
    ParseQuery<Message> oredQuery;

    isUpdating = true;

    Log.d("Conversations", "Skip is " + skip);

    orQueries.add(ParseQuery.getQuery(Message.class)
                    .whereEqualTo(Message.FROM_KEY, user1)
                    .whereEqualTo(Message.TO_KEY, user2)
    );
    orQueries.add(ParseQuery.getQuery(Message.class)
                    .whereEqualTo(Message.TO_KEY, user1)
                    .whereEqualTo(Message.FROM_KEY, user2)
    );
    oredQuery = ParseQuery.or(orQueries);
    oredQuery.include(Message.FROM_KEY).include(Message.TO_KEY);
    oredQuery.orderByDescending("createdAt");
    oredQuery.setLimit(limit);
    oredQuery.setSkip(skip);
    oredQuery.findInBackground(new FindCallback<Message>() {
        @Override
        public void done(List<Message> messages, ParseException e) {
            if (e == null) {
                if (messages.size() > 0) {
                    ParseUser fromUser = messages.get(0).getFromUser();
                    ParseUser toUser = messages.get(0).getToUser();
                    // Null users not allowed
                    if (fromUser == null || toUser == null) {
                        messages.clear();
                    }
                }
                callback.done(messages, e);
                isUpdating = false;
            }
        }
    });
}