Eagerly fetch query this association fetching some of the properties.
518586
protected R fetchQueryProperties(TQProperty<?>... props) {
    ((TQRootBean) _root).query().fetchQuery(_name, properties(props));
    return _root;
  }
818954
def fetchMore(self, parentIndex):  # TODO: Make LazyLoadRepoTreeModel?
        
        parentItem = self.getItem(parentIndex)
        if not parentItem:
            return

        if not parentItem.canFetchChildren():
            return

        # TODO: implement InsertItems to optimize?
        for childItem in parentItem.fetchChildren():
            self.insertItem(childItem, parentIndex=parentIndex)

        # Check that Rti implementation correctly sets canFetchChildren
        assert not parentItem.canFetchChildren(), \
            "not all children fetched: {}".format(parentItem)
998999
def get(self, *args, **kwargs):
        
        if self.query.where:
            # If there is any other ``where`` filter on this QuerySet just call
            # super. There will be a where clause if this QuerySet has already
            # been filtered/cloned.
            return super(CachingQuerySet, self).get(*args, **kwargs)
 
        # Punt on anything more complicated than get by pk/id only...
        if len(kwargs) == 1:
            k = kwargs.keys()[0]
            if k in ('pk', 'pk__exact', '%s' % self.model._meta.pk.attname, 
                     '%s__exact' % self.model._meta.pk.attname):
                obj = cache.get(self.model._cache_key(pk=kwargs.values()[0]))
                if obj is not None:
                    obj.from_cache = True
                    return obj
 
        # Calls self.iterator to fetch objects, storing object in cache.
        return super(CachingQuerySet, self).get(*args, **kwargs)
449283
def fetch_and_index(self, fetch_func):
        ""
        data, e = fetch_func()
        if e: raise e
        yield {row['id']: row for row in data}
400502
public void fetchMode(String associationPath, FetchMode fetchMode) {
        if (criteria != null) {
            criteria.setFetchMode(associationPath, fetchMode);
        }
    }
272109
def fetch(key, default=nil)
      found_in = self_and_sub_collections.detect{ |c| c[key] }
      raise KeyError unless found_in
      found_in[key]
    end
552325
def fetch(self, R, pk, depth=1):
        ""
        d, e = self._fetcher.fetch(R, pk, depth)
        if e: raise e
        return d
648449
def fetchmany(self, *args, **kwargs):
        

        if not self.single_cursor_mode:
            raise S3MError("Calling Connection.fetchmany() while not in single cursor mode")

        return self._cursor.fetchmany(*args, **kwargs)
1059856
def query(self, query, fetchall=False, **params):
        
        with self.get_connection() as conn:
            return conn.query(query, fetchall, **params)
1221797
public R fetch(String properties) {
    ((TQRootBean) _root).query().fetch(_name, properties);
    return _root;
  }
85798
function (model) {
            //if we have them return them;
            if (this.associationLoaded(model)) {
                var assoc = this.getAssociation(model);
                return this.isEager() ? assoc : when(assoc);
            } else if (model.isNew) {
                return null;
            } else {
                return this.fetch(model);
            }
        }
841945
function fetchViews(match) {
  var activeTrace = match.activeTrace.map(fetchViewsStep);

  return activeTrace.some(Promise.is) ?
    Promise.all(activeTrace).then((activeTrace) => merge(match, {activeTrace})) :
    Promise.resolve(merge(match, {activeTrace}));
}
155123
protected R fetchLazyProperties(TQProperty<?>... props) {
    ((TQRootBean) _root).query().fetchLazy(_name, properties(props));
    return _root;
  }
206345
def fetch(self):
        
        self.limit.set_request_args(self.kwargs)
        data = self.connection.call(*self.args, **self.kwargs)
        self.limit.post_fetch(data)
        self.last_evaluated_key = data.get('LastEvaluatedKey')
        if self.last_evaluated_key is None:
            self.kwargs.pop('ExclusiveStartKey', None)
        else:
            self.kwargs['ExclusiveStartKey'] = self.last_evaluated_key
        self._update_capacity(data)
        if 'consumed_capacity' in data:
            self.consumed_capacity += data['consumed_capacity']
        for raw_item in data['Items']:
            item = self.connection.dynamizer.decode_keys(raw_item)
            if self.limit.accept(item):
                yield item
906079
def fetch_data(self, **var):
        """"""
        varstr = ','.join(name + self._convert_indices(ind)
                          for name, ind in var.items())
        query = self.query().add_query_parameter(req='data', var=varstr)
        return self._fetch(query)
911739
def fetch_value(key)
      val = fetch_nested(key)
      return val if self[:no_pruning].include?(key)
      Prunable::VALUES.include?(val) ? Prunable::Value : val
    end
677710
static List<Entity> fetch(Transaction reader, Key... keys) {
    return compileEntities(keys, reader.get(keys));
  }