@return mixed

Returns assoc array of all records found:
$this->qb->table('users')->select('*')->getAll();
547998
public function fetchAll() {
        try {
            $query = $this->db->prepare($this->q->get());
            $this->bindValues($query);
            $query->execute();
            $this->clear();

            return $query->fetchAll(\PDO::FETCH_ASSOC);
        } catch (\PDOException $e) {
            $this->setError('d', $e->getMessage());
            return false;
        }
    }
968072
public function getUsers() {
	
		$this->db->setQuery('SELECT * FROM `users` WHERE group_id=?');
		$list = $this->db->loadObjectList($this->id);
	
		$users = array();
	
		$userClass = PAIR_USER_CLASS;
	
		// iterate on each page
		foreach ($list as $row) {
			$users[] = new $userClass($row);
		}
	
		return $users;
	
	}
55506
public function findAll() {
        $sql = $this->getSql();
        $params = array_merge($this->whereParams(), $this->having_params);
        $connection = Pool::get(Connection::class);
        try {
            $data = $connection->query($sql, $params, $this->cache);
            Pool::release($connection);
        } catch (\RuntimeException $e) {
            Pool::release($connection);
            throw $e;
        } catch (\Error $e) {
            Pool::release($connection);
            throw $e;
        }
        if ($this->clazz) {
            $results = [];
            l:
            /* @var $item */
            foreach ($data as $item) {
                $clazz = $this->clazz;
                $result = new $clazz;
                foreach ($this->subRecord as $pre => $sub) {
                    $pre .= "_";
                    $values = [];
                    $length = strlen($pre);
                    foreach ($item as $key => $value) {
                        if (strpos($key, $pre) === 0) {
                            unset($item[ $key ]);
                            $key = substr($key, $length);
                            $values[ $key ] = $value;
                        }
                    }
                    $clazz = $sub[ 'class' ];
                    $field = $sub[ 'field' ];
                    /* @var $subRecord Record */
                    $subRecord = new $clazz;
                    $subRecord->fromDbData($values);
                    if ($sub[ 'all_do' ]) {
                        $call = $sub[ 'all_do' ];
                        $call($subRecord);
                    }
                    $result->$field = $subRecord;
                }
                if ($result instanceof Record) {
                    $result->fromDbData($item);
                } else {
                    foreach ($item as $key => $value) {
                        $result->$key = $value;
                    }
                }
                $is_remove = false;
                if ($this->all_do) {
                    foreach ($this->all_do as $do) {
                        $return = $result->$do();
                        if ($return === self::REMOVED) {
                            $is_remove = true;
                            break;
                        }
                    }
                }
                if ($is_remove) {
                    continue;
                }
                if ($this->each) {
                    foreach ($this->each as $each) {
                        $return = $each($result);
                        if ($return === self::REMOVED) {
                            $is_remove = true;
                            break;
                        }
                    }
                }
                if ($is_remove) {
                    continue;
                }
                if ($this->to_array && $result instanceof Record) {
                    $result = $result->toArray($this->to_array, $this->to_array_contain);
                }
                $results[] = $result;
            }
            return $results;
        }
        return $data;
    }
214915
protected function allUsers()
    {
        $directory = Google::make('directory');
        $pageToken = null;
        $users = [];
        do {
            try {
                $r = $directory->users->listUsers([
                    'domain' => config('users.google_apps_domain'),
                    'maxResults' => config('users.google_apps_users_maxResults'),
                    'pageToken' => $pageToken
                ]);
                $pageToken = $r->nextPageToken;
                $users = array_merge($users, $r->users);
            } catch (\Exception $e) {
                return json_decode($e->getMessage());
            }
        } while ($pageToken);
        return $users;
    }
829154
public static function all()
    {
        try {
            self::init();
            $query = 'SELECT * FROM ' . self::$modelTable;
            $qb = new QueryBuilder(self::$connect, $query);
            return $qb->get();

        } catch (\Exception $exception) {
            var_dump($exception->getMessage());
        }
    }
20410
public static function findAll()
    {
        $s = new static();

        self::$db->select($s::$entity_table);

        return self::$db->objectSet(self::$child_class);
    }
316542
public function fetchAll() {
		if ($this->selection) {
			/** @var ActiveRow $entity */
			foreach ($this->selection as $entity) {
				$this->createEntity($entity);
			}
		}

		return $this->rows;
	}
1204803
public function findAll()
    {
        $appServerList = [];

        /** @var \OxidEsales\Eshop\Core\Database\Adapter\ResultSetInterface $resultList */
        $resultList = $this->selectAllData();
        if ($resultList != false && $resultList->count() > 0) {
            $result = $resultList->getFields();
            $serverId = $this->getServerIdFromConfig($result['oxvarname']);
            $information = $this->getValueFromConfig($result['oxvarvalue']);
            $appServerList[$serverId] = $this->createServer($information);
            while ($result = $resultList->fetchRow()) {
                $serverId = $this->getServerIdFromConfig($result['oxvarname']);
                $information = $this->getValueFromConfig($result['oxvarvalue']);
                $appServerList[$serverId] = $this->createServer($information);
            }
        }
        return $appServerList;
    }
1097475
public function getAll()
    {
        if (filesize($this->filename) <= static::MAX_FILE_SIZE_FOR_CACHE) {
            $return = $this->query(new Query());
        } else {
            $return = $this->getIterator();
        }

        return $return;
    }
1272594
public function findAll()
    {
        $ret = $this->conn()->selectCollection($this->table_name)->find($this->where, $this->field);
        if ($this->limit) {
            $ret->limit($this->limit)->skip($this->skip);
        }
        if ($this->orderby) {
            $ret->sort($this->orderby);
        }

        $this->sql = array(
                     'table'=> $this->table_name,
                     'query'=>$this->where,
                     'field'=> $this->field,
                     'limit'=> $this->limit,
                     'skip'=> $this->skip,
                   );
        $this->_clear_var();
        return $ret;
    }
730241
public function loadAllGroupsData()
    {
        $q = $this->createGroupLoadQuery();

        $stmt = $q->prepare();
        $stmt->execute();

        return $stmt->fetchAll(\PDO::FETCH_ASSOC);
    }
698660
public function all()
	{
		static $clean;

		if (isset($clean))
		{
			return $clean;
		}

		$Itemid   = $this->app['request']->getInt('Itemid');

		$user     = $this->app['user']->getInstance();
		$groups   = implode(',', $user->getAuthorisedViewLevels());
		$lang     = $this->app['language']->getTag();
		$clientId = (int) $this->app['client']->id;

		if (!$this->app->has('cache.store') || !($cache = $this->app['cache.store']))
		{
			$cache = new \Hubzero\Cache\Storage\None();
		}
		$cacheid = 'com_modules.' . md5(serialize(array($Itemid, $groups, $clientId, $lang)));

		if (!($clean = $cache->get($cacheid)))
		{
			$db = $this->app['db'];

			$query = $db->getQuery();

			$query
				->select('m.id')
				->select('m.title')
				->select('m.module')
				->select('m.position')
				->select('m.content')
				->select('m.showtitle')
				->select('m.params')
				->select('mm.menuid')
				->select('e.protected')
				->from('#__modules', 'm')
				->join('#__modules_menu AS mm', 'mm.moduleid', 'm.id', 'left')
				->whereEquals('m.published', 1);

			$query
				->joinRaw('#__extensions AS e', 'e.element = m.module AND e.client_id = m.client_id', 'left')
				->whereEquals('e.enabled', 1);

			$now = with(new Date('now'))->toSql();

			$query
				->where('m.publish_up', 'IS', null, 'and', 1)->orWhere('m.publish_up', '<=', $now, 1)->resetDepth()
				->where('m.publish_down', 'IS', null, 'and', 1)->orWhere('m.publish_down', '>=', $now, 1)->resetDepth();

			$query
				->whereIn('m.access', $user->getAuthorisedViewLevels())
				->whereEquals('m.client_id', $clientId)
				->whereEquals('mm.menuid', (int) $Itemid, 1)->orWhere('mm.menuid', '<=', '0', 1)->resetDepth();

			// Filter by language
			if ($this->app->isSite() && $this->app->get('language.filter'))
			{
				$query->whereIn('m.language', array($lang, '*'));
			}

			$query
				->order('m.position', 'asc')
				->order('m.ordering', 'asc');

			// Set the query
			$db->setQuery($query->toString());
			$modules = $db->loadObjectList();
			$clean = array();

			if ($db->getErrorNum())
			{
				$this->app['notification']->error(
					$this->app['language']->txt('JLIB_APPLICATION_ERROR_MODULE_LOAD', $db->getErrorMsg())
				);

				return $clean;
			}

			// Apply negative selections and eliminate duplicates
			$negId = $Itemid ? -(int) $Itemid : false;
			$dupes = array();
			for ($i = 0, $n = count($modules); $i < $n; $i++)
			{
				$module = &$modules[$i];

				// The module is excluded if there is an explicit prohibition
				$negHit = ($negId === (int) $module->menuid);

				if (isset($dupes[$module->id]))
				{
					// If this item has been excluded, keep the duplicate flag set,
					// but remove any item from the cleaned array.
					if ($negHit)
					{
						unset($clean[$module->id]);
					}
					continue;
				}

				$dupes[$module->id] = true;

				// Only accept modules without explicit exclusions.
				if (!$negHit)
				{
					$module->name     = substr($module->module, 4);
					$module->style    = null;
					$module->position = strtolower($module->position);

					$clean[$module->id] = $module;
				}
			}

			unset($dupes);

			// Return to simple indexing that matches the query order.
			$clean = array_values($clean);

			$cache->put($cacheid, $clean, $this->app['config']->get('cachetime', 15));
		}

		return $clean;
	}
663721
public function getLocalAccounts()
    {
        if (!is_null($this->localAccountCache)) {
            return $this->localAccountCache;
        }

        return $this->localAccountCache = array_map('strtolower',
            $this->db->get_col("SELECT user_login FROM " . $this->db->users . " ORDER BY RAND()"));
    }
1084084
protected function selFromDbAll()
    {
        $selectedRows = $this->doQuery($this->selFromDbAllQuery())->fetchAll();

        $this->query = null;

        // TODO [alek13]: bring it out
        if ($this->pagedQuery) {
            $row                = static::db()->getConnection()->query('SELECT FOUND_ROWS()')->fetch();
            $this->recordsCount = reset($row);
            $this->pagesCount   = ceil($this->recordsCount / $this->recordsPerPage);
        }

        return $selectedRows;
    }
280837
public function findAll()
    {
        // convert to criteria.
        $criteria = call_user_func_array(array($this, 'argsToCriteria'), func_get_args());
        
        // logical delete ?
        $schema = $this->getSchema();
        if ($schema->hasColumn('active')) {
            $criteria->where('active = ?', 1);
        }

        // to SQL.
        $sql = $criteria->toSQL();

        // query
        $sth = $this->query($sql, $criteria->getParams(), Database::TARGET_SLAVE);

        // to entities
        $entities = new Entities($this);
        $entities->setCriteria($criteria);
        foreach ($sth->fetchAll(Connection::FETCH_ASSOC) as $row) {
            $entities->add($this->build($row, true));
        }

        return $entities;
    }
1330664
public function getAllUsers() : array {
		$result = $this->db->query("SELECT id FROM accounts;");
		$users = [];
		foreach ($result->fetch_all(MYSQLI_ASSOC) as $user) {
			$users[(int)$user["id"]] = $this->getUserFromId((int)$user["id"]);
		}
		return $users;
	}
60610
public function getTotalRecords()
    {
        $qb = clone $this->queryBuilder;
        $this->_addSearch($qb);
        $qb->resetDQLPart('orderBy');

        $gb = $qb->getDQLPart('groupBy');
        if (empty($gb) || !in_array($this->fields['_identifier_'], $gb))
        {
            $qb->select(" count({$this->fields['_identifier_']}) ");
            return $qb->getQuery()->getSingleScalarResult();
        }
        else
        {
            $qb->resetDQLPart('groupBy');
            $qb->select(" count(distinct {$this->fields['_identifier_']}) ");
            return $qb->getQuery()->getSingleScalarResult();
        }
    }