Get the current result's data from the cursor.
333043
def get_result(self, cursor):
        ''''''
        title = headers = None

        # cursor.description is not None for queries that return result sets,
        # e.g. SELECT or SHOW.
        if cursor.description is not None:
            headers = [x[0] for x in cursor.description]
            rows = cursor.fetchall()
            status = '%d row%s in set' % (len(rows), '' if len(rows) == 1 else 's')
        else:
            logger.debug('No rows in result.')
            rows = None
            status = 'Query OK'
        return (title, rows, headers, status)
1281139
def result(self):
    
    self.wait()
    if self.failed:
      raise Exception('Query failed: %s' % str(self.errors))
    return self._table
647342
def log_results():
    """"""
    from furious.context import get_current_async

    # Get the recently finished Async object.
    async = get_current_async()

    # Pull out the result data and log it.
    for result in async.result:
        logging.info(result)
1322935
async def nextset(self):
        """"""
        conn = self._get_db()
        current_result = self._result
        if current_result is None or current_result is not conn._result:
            return
        if not current_result.has_next:
            return
        self._result = None
        self._clear_result()
        await conn.next_result()
        await self._do_get_result()
        return True
1124781
public function current()
	{
		if( !isset( $this->____pairs ) )
			$this->getPairs();
		$values	= array_values( $this->____pairs );
		return $values[$this->____cursor];
	}
335908
def cursor(self):
        """"""
        if self._cursor < 0:
            self.cursor = 0

        if self._cursor > len(self):
            self.cursor = len(self)

        return self._cursor
977184
def callback_result(self):
        """"""
        if self._state == self._PENDING:
            self._loop.run_until_complete(self)
        if self._callbacks:
            result = self._callback_result
        else:
            result = self.result()
        return result
1055250
async def cursor(self) -> Cursor:
        """"""
        return Cursor(self, await self._execute(self._conn.cursor))
617510
def cursor(self):
        
        cursor = self.mdr.cursor()
        with self.transaction():
            try:
                yield cursor
                if cursor.rowcount != -1:
                    self.last_row_count = cursor.rowcount
                self.last_row_id = getattr(cursor, 'lastrowid', None)
            except:
                self.last_row_count = None
                self.last_row_id = None
                _safe_close(cursor)
                raise
640269
def _cursor(self):
        """"""
        if self._conn is None:
            self._conn = sqlite3.connect(self.filename,
                                         check_same_thread=False)
        return self._conn.cursor()
268039
def next(self):
        """"""
        if self._current_index < len(self._collection):
            value = self._collection[self._current_index]
            self._current_index += 1
            return value
        elif self._next_cursor:
            self.__fetch_next()
            return self.next()
        else:
            self._current_index = 0
            raise StopIteration
1123335
def _produce_return(self, cursor):
        
        self.callback(self._row_generator(cursor), *self.cb_args)
        return None
911620
boolean getMoreResults(int current) throws SQLException {
        checkClosed();

        if (resultIn == null || !resultIn.isData()) {
            return false;
        }

        if (resultSetCounter == 0) {
            resultSetCounter++;
            return true;
        }

        if (currentResultSet != null && current != KEEP_CURRENT_RESULT) {
            currentResultSet.close();
        }

        resultIn = null;

        return false;
    }
329257
def iter_next(self):
        """"""
        self.cursor += self.batch_size
        return self.cursor < self.num_data
154209
def result(self):
        
        final_result = {'epoch_idx': self.global_epoch_idx}

        for key, value in self.frozen_results.items():
            final_result[key] = value

        return final_result
1050447
def _produce_return(self, cursor):
        
        results = cursor.fetchmany(2)
        if len(results) != 1:
            return None

        # Return the one row, or the one column.
        row = results[0]
        if self._row_formatter is not None:
            row = self._row_formatter(row, cursor)
        elif len(row) == 1:
            row = row[0]

        return row
546053
def row(self):
        """"""
        ret = None
        i = self.tableWidget.currentRow()
        if i >= 0:
            ret = self._data[i]
        return ret