Fetch the next page of ids from the database
162124
protected function fetchNextRecords()
    {
        if (!$this->use_fixed_offset) {
            $this->query->offset($this->query_offset);
        }
        if ($this->clean_memory_on_fetch) {
            // Attempt to clean php memory
            $this->results_cache = null;
            BeanFactoryCache::clearCache();
            gc_collect_cycles();
        }
        $this->results_cache = $this->query->execute();
        $this->cache_current_index = 0;
    }
483304
def _next_numId(self):
        
        numId_strs = self.xpath('./w:num/@w:numId')
        num_ids = [int(numId_str) for numId_str in numId_strs]
        for num in range(1, len(num_ids)+2):
            if num not in num_ids:
                break
        return num
513781
def _continued_query(self, query_params, key="pages"):
        
        query_params.update(self.__title_query_param())

        last_cont = dict()
        prop = query_params.get("prop")

        while True:
            params = query_params.copy()
            params.update(last_cont)

            request = self.mediawiki.wiki_request(params)

            if "query" not in request:
                break

            pages = request["query"][key]
            if "generator" in query_params:
                for datum in pages.values():
                    yield datum
            elif isinstance(pages, list):
                for datum in list(enumerate(pages)):
                    yield datum[1]
            else:
                for datum in pages[self.pageid].get(prop, list()):
                    yield datum

            if "continue" not in request or request["continue"] == last_cont:
                break

            last_cont = request["continue"]
483694
def select_next(self):
        """"""
        self.footer.clear_message()

        old_index = self.selected
        new_index = self.selected + 1

        # Load more statuses if no more are available
        if self.selected + 1 >= len(self.statuses):
            self.fetch_next()
            self.left.draw_statuses(self.statuses, self.selected, new_index - 1)
            self.draw_footer_status()

        self.selected = new_index
        self.redraw_after_selection_change(old_index, new_index)
418942
final public WebPage getNextPage(WebSiteRequest req) throws IOException, SQLException {
		WebPage parent=getParent();
		if (parent!=null) {
			WebPage[] myPages=parent.getCachedPages(req);
			int len=myPages.length;
			for(int c=0; c<len; c++) {
				if(myPages[c].getClass() == getClass()) {
					if (c < (len - 1)) return myPages[c + 1];
					return null;
				}
			}
		}
		return null;
	}
33749
def next(self):
        """"""
        if self.iter == None:
            self.iter = iter(self.objs)
        try:
            return self.iter.next()
        except StopIteration:
            self.iter = None
            self.objs = []
            if int(self.page) < int(self.total_pages):
                self.page += 1
                self._connection.get_response(self.action, self.params, self.page, self)
                return self.next()
            else:
                raise
1372436
def next_page(self):
        
        if self.page.has_next():
            self.query_dict['page'] = self.page.next_page_number()
            return "%s?%s" % (self.path, urlencode(self.query_dict))
        return ""
467515
def _get_all(self):
        ''' 
        '''
        rowid = 0
        while True:
            SQL_SELECT_MANY = 'SELECT rowid, * FROM %s WHERE rowid > ? LIMIT ?;' % self._table
            self._cursor.execute(SQL_SELECT_MANY, (rowid, ITEMS_PER_REQUEST))
            items = self._cursor.fetchall()
            if len(items) == 0:
                break
            for item in items:
                rowid = item['_id']
                yield self._make_item(item)
51529
def pages(self, limit=0):
        """"""
        if limit > 0:
            self.iterator.limit = limit
        return self.iterator
851858
public function next()
    {
        $this->key++;
        if (\PDO::FETCH_COLUMN !== $this->fetchMode) {
            $this->current = $this->queryResult->fetch(
                    $this->fetchMode,
                    $this->driverOptions
            );
        } else {
            $this->current = $this->queryResult->fetchOne(
                    $this->driverOptions['columnIndex'] ?? 0
            );
        }
    }
1371354
def previous_page(params = {}, opts = {})
      first_id = data.first.id

      params = filters.merge(ending_before: first_id).merge(params)

      list(params, opts)
    end
305205
def get(self, id):
        ''''''
        args = parser.parse_args()
        model = self.model.objects.only('id').get_or_404(id=id)
        qs = Follow.objects(following=model, until=None)
        return qs.paginate(args['page'], args['page_size'])
1374157
protected void getNextPage() {
		    	    	
        final JSONObject params = new JSONObject();
        
        page++;
        
        params.put("page", page);
        params.put("size", size);
        
        clear();
        
        getPage(params);
                
	}
588955
def nextId(self):
        
        if self._next_id is False:
            # Request the next urn
            self._prev_id, self._next_id = self.getPrevNextUrn(reference=self.urn.reference)
        return self._next_id
1092322
def _next_page(self):
        
        if not self._has_next_page():
            return None

        if self.next_page_token is not None:
            setattr(self._request, self._request_token_field, self.next_page_token)

        response = self._method(self._request)

        self.next_page_token = getattr(response, self._response_token_field)
        items = getattr(response, self._items_field)
        page = Page(self, items, self.item_to_value)

        return page
1165000
def _get_next_nn_id(self):
        """"""
        self._nn_id = self._nn_id + 1 if self._nn_id < 126 else 1
        return self._nn_id * 2
873248
def next_row(self):
        """"""
        row = self.currentIndex().row()
        rows = self.proxy_model.rowCount()
        if row + 1 == rows:
            row = -1
        self.selectRow(row + 1)