def aggregate(self, kwargs): '''Aggregate lookup parameters.''' meta = self._meta fields = meta.dfields field_lookups = {} for name, value in iteritems(kwargs): bits = name.split(JSPLITTER) field_name = bits.pop(0) if field_name not in fields: raise QuerySetError('Could not filter on model "{0}".\ Field "{1}" does not exist.'.format(meta, field_name)) field = fields[field_name] attname = field.attname if bits: bits = [n.lower() for n in bits] if bits[-1] == 'in': bits.pop() lookup = JSPLITTER.join(bits) if lookup and lookup not in range_lookups: lvalue = field.filter(self.session, lookup, value) if lvalue is not None: value = lvalue lookup = None else: if bits[-1] in range_lookups: lookup = bits.pop() else: lookup = None bits.insert(0, attname) attname = JSPLITTER.join(bits) else: lookup = None # Get lookups on attribute name lookups = field_lookups.get(attname) if lookups is None: lookups = [] field_lookups[attname] = lookups if lookup not in range_lookups: if not field.index: raise QuerySetError("{0} {1} is not an index.\ Cannot query.".format(field.__class__.__name__,field_name)) if not iterable(value): value = (value,) for v in value: if isinstance(v, Q): v = lookup_value('set', v.construct()) else: v = lookup_value('value', field.dumps(v, lookup)) lookups.append(v) else: lookups.append(lookup_value(lookup, field.dumps(value, lookup))) return [queryset(self, name=name, underlying=field_lookups[name])\ for name in sorted(field_lookups)]
def load_only(self, *fields): '''This is provides a :ref:`performance boost <increase-performance>` in cases when you need to load a subset of fields of your model. The boost achieved is less than the one obtained when using :meth:`Query.load_related`, since it does not reduce the number of requests to the database. However, it can save you lots of bandwidth when excluding data intensive fields you don't need. ''' q = self._clone() new_fields = [] for field in fields: if JSPLITTER in field: bits = field.split(JSPLITTER) related = self._get_related_field(bits[0]) if related: q._add_to_load_related(related, JSPLITTER.join(bits[1:])) continue new_fields.append(field) if fields and not new_fields: # if we added a field to the load_related list and not fields are # are left we add the primary key so that other firls are not # loaded. new_fields.append(self._meta.pkname()) fs = unique_tuple(q.fields, new_fields) q.data['fields'] = fs if fs else None return q
def aggregate(self, kwargs): """Aggregate lookup parameters.""" meta = self._meta fields = meta.dfields field_lookups = {} for name, value in iteritems(kwargs): bits = name.split(JSPLITTER) field_name = bits.pop(0) if field_name not in fields: raise QuerySetError( 'Could not filter on model "{0}".\ Field "{1}" does not exist.'.format( meta, field_name ) ) field = fields[field_name] attname = field.attname lookup = None if bits: bits = [n.lower() for n in bits] if bits[-1] == "in": bits.pop() elif bits[-1] in range_lookups: lookup = bits.pop() remaining = JSPLITTER.join(bits) if lookup: # this is a range lookup attname, nested = field.get_lookup(remaining, QuerySetError) lookups = get_lookups(attname, field_lookups) lookups.append(lookup_value(lookup, (value, nested))) continue elif remaining: # Not a range lookup, must be a nested filter value = field.filter(self.session, remaining, value) lookups = get_lookups(attname, field_lookups) # If we are here the field must be an index if not field.index: raise QuerySetError("%s %s is not an index. Cannot query." % (field.__class__.__name__, field_name)) if not iterable(value): value = (value,) for v in value: if isinstance(v, Q): v = lookup_value("set", v.construct()) else: v = lookup_value("value", field.serialise(v, lookup)) lookups.append(v) # return [queryset(self, name=name, underlying=field_lookups[name]) for name in sorted(field_lookups)]
def aggregate(self, kwargs): '''Aggregate lookup parameters.''' meta = self._meta fields = meta.dfields field_lookups = {} for name, value in iteritems(kwargs): bits = name.split(JSPLITTER) field_name = bits.pop(0) if field_name not in fields: raise QuerySetError('Could not filter on model "{0}".\ Field "{1}" does not exist.'.format(meta, field_name)) field = fields[field_name] attname = field.attname lookup = None if bits: bits = [n.lower() for n in bits] if bits[-1] == 'in': bits.pop() elif bits[-1] in range_lookups: lookup = bits.pop() remaining = JSPLITTER.join(bits) if lookup: # this is a range lookup attname, nested = field.get_lookup(remaining, QuerySetError) lookups = get_lookups(attname, field_lookups) lookups.append(lookup_value(lookup, (value, nested))) continue elif remaining: # Not a range lookup, must be a nested filter value = field.filter(self.session, remaining, value) lookups = get_lookups(attname, field_lookups) # If we are here the field must be an index if not field.index: raise QuerySetError("%s %s is not an index. Cannot query." % (field.__class__.__name__, field_name)) if not iterable(value): value = (value,) for v in value: if isinstance(v, Q): v = lookup_value('set', v.construct()) else: v = lookup_value('value', field.serialise(v, lookup)) lookups.append(v) # return [queryset(self, name=name, underlying=field_lookups[name]) for name in sorted(field_lookups)]