Returns the full query for this widget.  This will reflect the complete
        combined query for all containers within this widget.
        
        :return     <orb.Query>
165358
def query(self):
        
        if self._loadQuery is not None:
            return self._loadQuery
        
        container = self.widget(0)
        if container:
            query = container.query()
        else:
            query = Query()
        
        return query
789977
def all(self):
    " "
    query,inputs = self._toedn()
    return self.db.q(query,
      inputs  = inputs,
      limit   = self._limit,
      offset  = self._offset,
      history = self._history)
817890
def currentQuery( self ):
        
        widgets = self.lineWidgets()
        output = []
        for widget in widgets:
            output.append(widget.query())
        return output
1078926
def query(cls, offset=None, limit=None, api=None):
        
        api = api if api else cls._API
        return super(Division, cls)._query(
            url=cls._URL['query'], offset=offset, limit=limit,
            fields='_all', api=api
        )
837117
def query(self):
        
        ret = MultiDict(parse_qsl(self.raw_query_string, keep_blank_values=True))
        return MultiDictProxy(ret)
1304016
def get_containers(self):
        
        query = dict(portal_type="Container",
                     sort_on="sortable_title",
                     sort_order="ascending",
                     is_active=True)
        results = api.search(query, "bika_setup_catalog")
        return map(api.get_object, results)
1173196
def query( self ):
        
        # build a query if not searching all
        q        = Q()
        operator = 'and'
        
        for i in range(self.uiQueryTREE.topLevelItemCount()):
            item = self.uiQueryTREE.topLevelItem(i)
            
            if ( isinstance(item, XQueryItem) ):
                if ( operator == 'and' ):
                    q &= item.query()
                else:
                    q |= item.query()
            else:
                operator = nativestring(item.text(0))
        return q
1132955
def query(self, *q):
    
    params = join_params(self.parameters, {"q": q})

    return self.__class__(**params)
873407
def get_splits_query(self):
        
        query = (
            self.book.session.query(Split)
            # .join(Transaction)
            .filter(Split.transaction_guid == self.transaction.guid)
        )
        return query
825088
def find_all(query: Query=None) -> List['ApiKey']:
        
        return [ApiKey.from_db(key) for key in db.get_keys(query)]
1059856
def query(self, query, fetchall=False, **params):
        
        with self.get_connection() as conn:
            return conn.query(query, fetchall, **params)
1352894
def get_all(cls):
    

    req = datastore.RunQueryRequest()
    q = req.query
    set_kind(q, kind='Todo')
    add_property_orders(q, 'created')
    resp = datastore.run_query(req)
    todos = [Todo.from_proto(r.entity) for r in resp.batch.entity_results]
    return todos
273929
def query(self):
        
        tree = pypeg2.parse(self._query, parser(), whitespace="")
        for walker in query_walkers():
            tree = tree.accept(walker)
        return tree
391627
def Query(self, query, parameters=None):
    
    # TODO: catch Warning and return None.
    # Note that we cannot pass parameters as a keyword argument here.
    # A parameters value of None is not supported.
    if parameters:
      self._cursor.execute(query, parameters)
    else:
      self._cursor.execute(query)

    return self._cursor.fetchall()
1242982
def selected(self):
        
        query_results = self.map(lambda el: el.is_selected(), 'selected').results
        if query_results:
            return all(query_results)
        return False
36484
def _query(cls, **kwargs):
        
        from sevenbridges.models.link import Link
        from sevenbridges.meta.collection import Collection

        api = kwargs.pop('api', cls._API)
        url = kwargs.pop('url')
        extra = {'resource': cls.__name__, 'query': kwargs}
        logger.info('Querying {} resource'.format(cls), extra=extra)
        response = api.get(url=url, params=kwargs)
        data = response.json()
        total = response.headers['x-total-matching-query']

        items = [cls(api=api, **item) for item in data['items']]
        links = [Link(**link) for link in data['links']]
        href = data['href']
        return Collection(
            resource=cls, href=href, total=total, items=items,
            links=links, api=api
        )
310827
def query_all(**kwargs):
        '''
        
        '''
        kind = kwargs.get('kind', '1')
        limit = kwargs.get('limit', 10)

        return TabPost.select().where(
            (TabPost.kind == kind) &
            (TabPost.valid == 1)
        ).order_by(
            TabPost.time_update.desc()
        ).limit(limit)