Fetches all data for the given handles. Returns Array with hashes of
 entity data
767105
def get_data_array(handles)
      return [] unless handles && handles.any?

      entity_class_name_for_soap_request = entity_class.name.split("::").last
      response = request(:get_data_array, "entityHandles" => {"#{entity_class_name_for_soap_request}Handle" => handles.collect(&:to_hash)})
      [response["#{entity_class.key}_data".intern]].flatten
    end
46820
function fetchAll($fetchMode = PDO::FETCH_ASSOC) {
        return $this->_data($this->query()->fetchAll($fetchMode),true);
    }
771210
def get_all_keys(self, headers=None, **params):
        
        key = Key(self.name, self.contained_key)
        return SimpleResultSet([key])
1336618
def get_all(cls):
        '''  '''
        redis = cls.get_redis()

        return list(map(
            lambda id: cls.get(id),
            map(
                debyte_string,
                redis.smembers(cls.members_key())
            )
        ))
1245548
@Override
	public Object retrieve(int handle) throws DataStoreException
    {
        if (SAFE_MODE) checkHandle(handle);
        return data[handle];
    }
1366256
public function getAll()
    {
        $query = $this->createQuery();
        $result = $this->database->query($query);

        $entities = [];
        if ($result) {
            $result = $result->fetchAll(\PDO::FETCH_ASSOC);
            $entities = $this->handleResult($result);
        }
        if ($this->returnOne && is_array($entities)) {
            return current($entities);
        }
        return $entities;
    }
518779
def list_sobjects
      result = http_get("/services/data/v#{self.version}/sobjects")
      if result.is_a?(Net::HTTPOK)
        JSON.parse(result.body)["sobjects"].collect { |sobject| sobject["name"] }
      elsif result.is_a?(Net::HTTPBadRequest)
        raise SalesForceError.new(result)
      end
    end
53458
def fetch_records(grouped_results)
      records = []
      grouped_results.each do |model, ids|
        klass = model.to_s.camelize.constantize
        if @queue.eager_loads && @queue.eager_loads[model]
          records += klass.includes(@queue.eager_loads[model]).find_all_by_id(ids)
        else
          records += klass.find_all_by_id(ids)
        end
      end
      records
    end
483497
async def fetchall(self):
        
        rows = []
        while True:
            row = await self.fetchone()
            if row is None:
                break
            rows.append(row)
        return rows
784047
function getIndexes(done, results) {
  var client = results.client;
  var ns = mongodbNS(results.namespace);
  client
    .db(ns.database)
    .collection(ns.collection)
    .indexes(function(err, indexes) {
      if (err) {
        done(err);
      }
      // add ns field to each index
      _.each(indexes, function(idx) {
        idx.ns = ns.ns;
      });
      done(null, indexes);
    });
}
377119
public function getInstalledHandles()
    {
        $query = 'select p.pkgHandle from \\Concrete\\Core\\Entity\\Package p';
        $r = $this->entityManager->createQuery($query);
        $result = $r->getArrayResult();
        $handles = [];
        foreach ($result as $r) {
            $handles[] = $r['pkgHandle'];
        }

        return $handles;
    }
589173
def _fetch_objects(self, key, value):
        """"""
        return self.to_cls.query.filter(**{key: value})
1264274
def fetchall(self):
        
        result = []
        iterate = True
        while iterate:
            try:
                result.append(self.next())
            except StopIteration:
                iterate = False
        return result
884548
def get_all(cls, parent=None, **params):

        if parent is not None:
            route = copy(parent.route)
        else:
            route = {}
        if cls.ID_NAME is not None:
            # Empty string triggers "get all resources"
            route[cls.ID_NAME] = ""

        base_obj = cls(key=parent.key, route=route, config=parent.config)
        """"""

        start = datetime.now()
        r = requests.get(
            base_obj._url(), auth=(base_obj.key, ""), params=params)
        cls._delay_for_ratelimits(start)

        if r.status_code not in cls.TRUTHY_CODES:
            return base_obj._handle_request_exception(r)

        response = r.json()
        objects_data = response.get(base_obj.ENVELOPE or base_obj, [])

        return_objects = []
        for data in objects_data:
            # Note that this approach does not get meta data
            return_objects.append(
                cls.get(
                    parent=parent,
                    id=data.get(cls.ID_NAME, data.get("id")),
                    data=data))

        return return_objects
863182
public function fetchAll()
    {
        $query = sprintf('SELECT * FROM `%s`', $this->table);
        $rows = array();

        foreach ($this->pdo->query($query) as $index => $row) {
            $value =& $row[ConstProviderInterface::CONFIG_PARAM_VALUE];

            if ($this->serializer->isSerialized($value)) {
                $value = $this->serializer->unserialize($value);
            }

            array_push($rows, $row);
        }

        return $rows;
    }
77508
protected function fetchKeys()
	{
		if($this->keyField===false)
			return array_keys($this->rawData);
		$keys=array();
		foreach($this->getData() as $i=>$data)
			$keys[$i]=is_object($data) ? $data->{$this->keyField} : $data[$this->keyField];
		return $keys;
	}
232828
def getRecords(rids, dbid = @dbid, fieldNames = nil)
      records = []
      if rids.length > 0
        query = ""
        rids.each{|rid| query << "{'3'.EX.'#{rid}'}OR"}
        query[-2] = "" 
        fieldNames ||= getFieldNames(dbid)
        iterateRecords(dbid,fieldNames,query){|r| records << r }
      end
      if block_given?
        records.each{|rec|yield rec}
      else
        records  
      end        
   end