Fetch the next row
514280
def fetchone(self):
        """"""
        self._check_executed()
        if self._rows is None or self.rownumber >= len(self._rows):
            return None
        result = self._rows[self.rownumber]
        self.rownumber += 1
        return result
339747
def next(self):
    
    out = self.peek()[self._headers.index(self._field)]
    self._cursor += 1
    if out is not None:
      self._lastValue = out
    return out
953638
public function fetchRow()
	{
		if( isset( $this->rows[$this->cursor] ) )
		{
			$row = $this->rows[$this->cursor];
			return $row->getValues();
		}
		else return FALSE;
	}
546053
def row(self):
        """"""
        ret = None
        i = self.tableWidget.currentRow()
        if i >= 0:
            ret = self._data[i]
        return ret
613745
def next(self):
        
        try:
            return self.dict_to_xn(self.csvreader.next())
        except MetadataException:
            # row was metadata; proceed to next row
            return next(self)
1276922
def fetch_next_page(self):
        
        for page in self:
            return page
        else:
            return Page(self._resultset.cursor, iter(()))
329257
def iter_next(self):
        """"""
        self.cursor += self.batch_size
        return self.cursor < self.num_data
1325550
@Override
    public boolean advanceNextPosition()
    {
        boolean needNextRows = !started || !nextRows.hasNext();

        if (!started) {
            started = true;
            nanoStart = System.nanoTime();
        }

        if (needNextRows) {
            currentRow = null;
            try {
                do {
                    if (!scanner.hasMoreRows()) {
                        return false;
                    }

                    nextRows = scanner.nextRows();
                }
                while (!nextRows.hasNext());
                log.debug("Fetched " + nextRows.getNumRows() + " rows");
            }
            catch (KuduException e) {
                throw new RuntimeException(e);
            }
        }

        currentRow = nextRows.next();
        totalBytes += getRowLength();
        return true;
    }
651116
public function loadNextRow()
    {
        $this->connect();

        // Execute the query and get the result set cursor.
        if (!$this->executed) {
            if (!($this->execute())) {
                return $this->errorNum ? null : false;
            }
        }

        // Get the next row from the result set as an object of type $class.
        if ($row = $this->fetchArray()) {
            return $row;
        }

        // Free up system resources and return.
        $this->freeResult();

        return false;
    }
199886
def fetch_next_page(self):
        """"""
        result = self.request_handler.get(url=self.next_page_url).json()
        self.__init__(self.request_handler, result,
                      self.data_type, self.automatic_pagination)
1085071
public Row nextRow(int cnt) {
        Row lastrow = null;
        for (int i = 0; i < cnt; i++) {
            lastrow = this.nextRow();
        }
        return lastrow;
    }
375036
public function next()
    {
        $this->_row = $this->fetch();

        if ( !empty( $this->_row ) )
        {
            $this->_index++;
        }
    }
1222328
def get(self, query, *parameters, **kwargs):
        """"""
        rows = self.query(query, *parameters, **kwargs)
        if not rows:
            return None
        elif len(rows) > 1:
            raise ValueError('Multiple rows returned for get() query')
        else:
            return rows[0]
858833
@Override
    public boolean next() throws SQLException {
        notClosed();
        if (!this.hasNext()) {
            this.row = null;
            this.currentValue = null;
            return false;
        }

        this.row = rowIter.nextRow();
        return true;
    }
382511
@Override
    public boolean next() throws SQLException {
        checkClosed();
        if (cursorPosition == Position.afterLast || table.getActiveRowIndex() == rowCount - 1) {
            cursorPosition = Position.afterLast;
            return false;
        }
        if (cursorPosition == Position.beforeFirst) {
            cursorPosition = Position.middle;
        }
        try {
            return table.advanceRow();
        } catch (Exception x) {
            throw SQLError.get(x);
        }
    }
1038002
private function fetchRow()
    {
        ++$this->cursor;
        $imageId = $this->rowReader->getRow();

        if (substr($imageId, 0, strlen($this->prefix)) == $this->prefix) {
            $imageId = ltrim(substr($imageId, strlen($this->prefix)), '/');
        }

        $this->item = $imageId;
    }
1297307
public function fetchRow()
    {
        $opts = $this->options;
        $opts['limit'] = 1;
        
        $sql = QueryBuilder::optionsToSql($opts);
        $row = $this->getDb()->getRow($sql);
        
        return $row;        
    }