Fetch all of the remaining results from the last getDelayed() request.

Note that currently getDelayed is a synchronous call.

@return array The remaining results, or false if there are no results.
764446
public function fetchAll() {
    if (!empty($this->delayed_results)) {
      $result = $this->delayed_results;
      $this->delayed_results = array();
      return $result;
    } else {
      return false;
    }
  }
828669
public function fetchAll()
	{
		if ($this->result === null) {
			$this->query();
		}
		$machine = $this->machine;

		$id_keys = $this->machine->describeId();

		if (count($id_keys) == 1) {
			$list = array();
			while(($properties = $this->result->fetch(\PDO::FETCH_ASSOC))) {
				$item = $machine->hotRef($machine->decodeProperties($properties));
				$list[$item->id] = $item;
			}
			return $list;
		} else {
			return array_map(function($properties) use ($machine) {
					return $machine->hotRef($machine->decodeProperties($properties));
				}, $this->result->fetchAll(\PDO::FETCH_ASSOC));
		}
	}
1021675
public function getData()
    {
        $limit = $this->getLimit();
        $this->setHeaders();
        $page  = $this->getPage();
        if ($page > 0) {
            $page-=1;
        }
        return $this->getDataSource()->limit($limit)->offset($limit * $page)->getAll();
    }
427955
public function getLastRequestInformation()
    {
        return array(
            'http_url' => $this->http_url,
            'http_request_headers' => $this->http_request_headers,
            'http_code' => $this->http_code,
            'http_info' => $this->http_info,
            'http_header' => $this->http_header,
            'http_post' => $this->http_post,
        );
    }
1264274
def fetchall(self):
        
        result = []
        iterate = True
        while iterate:
            try:
                result.append(self.next())
            except StopIteration:
                iterate = False
        return result
444288
public function getAll()
    {
        $requests = [
            'schedule' => $this->buildGetRequest(self::ZF_SCHEDULE_URI, [], $this->headers, true),
            'cet' => $this->buildGetRequest(self::ZF_CET_URI, [], $this->headers, true),
            'exam' => $this->buildGetRequest(self::ZF_EXAM_URI, [], $this->headers, true),
        ];
        // Wait on all of the requests to complete. Throws a ConnectException
        // if any of the requests fail
        $results = Promise\unwrap($requests);

        // Wait for the requests to complete, even if some of them fail
        // $results = Promise\settle($requests)->wait();

        //Parser the data we need.
        $schedule = $this->parserSchedule($results['schedule']->getBody());
        $cet = $this->parserCommonTable($results['cet']->getBody());
        $exam = $this->parserCommonTable($results['exam']->getBody());

        return compact('schedule', 'cet', 'exam');
    }
604907
public function all()
	{
		$result = array();

		$data = $this->data();
		if ( ! is_array($data))
			$data = array($data);

		foreach ($data as $entry) {
			$result[] = $this->resolveActionFromStdClass($entry);
		}

		return $result;
	}
472384
protected function _fetch() {
		if (!$this->_resource instanceof PDOStatement) {
			$this->close();
			return false;
		}
		try {
			if ($result = $this->_resource->fetch(PDO::FETCH_NUM)) {
				return [$this->_iterator++, $result];
			}
		} catch (PDOException $e) {
			$this->close();
			return false;
		}
		return null;
	}
1002835
public function fetchFirst(): ?array
    {
        if (!$this->wasExecuted()) {
            $this->exec();
        }

        $this->resetLimit()->limit(0, 1);
        $results = $this->fetchAll();
        return isset($results[0]) ? $results[0] : null;
    }
829084
public function getResults()
    {
        // Get request data from request handler
        $request = $this->getRequestHandler()->getRequest();

        $searchTerms = $request->requestVar('Search');
        $query = SearchQuery::create()->addSearchTerm($searchTerms);

        if ($start = $request->requestVar('start')) {
            $query->setStart($start);
        }

        $params = [
            'spellcheck' => 'true',
            'spellcheck.collate' => 'true',
        ];

        // Get the first index
        $indexClasses = FullTextSearch::get_indexes(SolrIndex::class);
        $indexClass = reset($indexClasses);

        /** @var SolrIndex $index */
        $index = $indexClass::singleton();
        $results = $index->search($query, -1, -1, $params);

        // filter by permission
        if ($results) {
            foreach ($results->Matches as $match) {
                /** @var DataObject $match */
                if (!$match->canView()) {
                    $results->Matches->remove($match);
                }
            }
        }
        return $results;
    }
922873
public function getResult($limit = 0, $offset = 0)
    {
        if ($limit > 0 && false === $this->limitOffset($limit, $offset)) {
            return [];
        }

        $stmt = $this->queryBuilder->execute();
        $this->result = $stmt->fetchAll();

        return $this->result;
    }
231121
public function fetchAll(): array
    {
        $st = $this->run();
        try {
            return $st->fetchAll(\PDO::FETCH_ASSOC);
        } finally {
            $st->close();
        }
    }
1197687
public function all()
    {
        $handles = $this->client
            ->DebtorContact_GetAll()
            ->DebtorContact_GetAllResult
            ->DebtorContactHandle;

        return $this->getArrayFromHandles($handles);
    }
1001197
public function getAll(){
        $rest = $this->getService( self::API_CALL_LOG);
        $rest->GET();

        return $rest->getResultAsArray( models\Call\CallEntry::class);
    }
931860
public function findRedirectsByDemand(): array
    {
        return $this->getQueryBuilderForDemand()
            ->setMaxResults($this->demand->getLimit())
            ->setFirstResult($this->demand->getOffset())
            ->execute()
            ->fetchAll();
    }
1016396
public function flush()
    {
        $flushCallback = function ($allFlushed, $cache) {
            return $allFlushed && $cache->flush();
        };
        return array_reduce($this->caches, $flushCallback, true);
    }
1061556
public function getNbResults()
    {
        if (!$this->resultSet) {
            return $this->searchable->search($this->query)->getTotalHits();
        }

        return $this->resultSet->getTotalHits();
    }