From 83f88704897d387db43516f7271c239fe8ed7549 Mon Sep 17 00:00:00 2001 From: Adrian Holovaty Date: Sun, 29 Jan 2006 02:02:58 +0000 Subject: [PATCH] magic-removal: Removed unnecessary legacy 'import copy' and restored some spacing that had been changed (for easier understanding of diffs) git-svn-id: http://code.djangoproject.com/svn/django/branches/magic-removal@2156 bcc190cf-cafb-0310-a4f2-bffc1f526a37 --- django/db/models/manager.py | 17 +++++----- django/db/models/query.py | 63 ++++++++++++++++++------------------- 2 files changed, 37 insertions(+), 43 deletions(-) diff --git a/django/db/models/manager.py b/django/db/models/manager.py index cefe2ab9ab..9a2f536d8e 100644 --- a/django/db/models/manager.py +++ b/django/db/models/manager.py @@ -7,7 +7,6 @@ from django.db.models.query import handle_legacy_orderlist, orderlist2sql, order from django.dispatch import dispatcher from django.db.models import signals from django.utils.datastructures import SortedDict -import copy # Size of each "chunk" for get_iterator calls. # Larger values are slightly faster at the expense of more storage space. @@ -19,7 +18,6 @@ def ensure_default_manager(sender): # Create the default manager, if needed. if hasattr(cls, 'objects'): raise ValueError, "Model %s must specify a custom Manager, because it has a field named 'objects'" % name - cls.add_to_class('objects', Manager()) cls.objects._prepare() @@ -35,7 +33,7 @@ class Manager(QuerySet): self.creation_counter = Manager.creation_counter Manager.creation_counter += 1 self.klass = None - + def _prepare(self): pass # TODO @@ -60,7 +58,7 @@ class Manager(QuerySet): raise self.klass.DoesNotExist, "%s does not exist for %s" % (self.klass._meta.object_name, kwargs) assert len(obj_list) == 1, "get_object() returned more than one %s -- it returned %s! Lookup parameters were %s" % (self.klass._meta.object_name, len(obj_list), kwargs) return obj_list[0] - + def in_bulk(self, id_list, **kwargs): assert isinstance(id_list, list), "in_bulk() must be provided with a list of IDs." assert id_list != [], "in_bulk() cannot be passed an empty ID list." @@ -68,8 +66,8 @@ class Manager(QuerySet): if kwargs: new_query = self.filter(**kwargs) new_query = new_query.extras(where= - ["%s.%s IN (%s)" % (backend.quote_name(self.klass._meta.db_table), - backend.quote_name(self.klass._meta.pk.column), + ["%s.%s IN (%s)" % (backend.quote_name(self.klass._meta.db_table), + backend.quote_name(self.klass._meta.pk.column), ",".join(['%s'] * len(id_list)))], params=id_list) obj_list = list(new_query) @@ -82,7 +80,7 @@ class Manager(QuerySet): # Check for at least one query argument. if not kwargs and not delete_all: raise TypeError, "SAFETY MECHANISM: Specify DELETE_ALL=True if you actually want to delete all data." - + if kwargs: del_query = self.filter(**kwargs) else: @@ -99,8 +97,8 @@ class Manager(QuerySet): # Perform the SQL delete cursor = connection.cursor() _, sql, params = del_query._get_sql_clause(False) - cursor.execute("DELETE " + sql, params) - + cursor.execute("DELETE " + sql, params) + class OldManager(object): # Tracks each time a Manager instance is created. Used to retain order. @@ -369,5 +367,4 @@ class ManagerDescriptor(object): def __get__(self, instance, type=None): if instance != None: raise AttributeError, "Manager isn't accessible via %s instances" % type.__name__ - return self.manager diff --git a/django/db/models/query.py b/django/db/models/query.py index acac3b2c2a..cdca7c002f 100644 --- a/django/db/models/query.py +++ b/django/db/models/query.py @@ -68,7 +68,7 @@ class QuerySet(object): self._offset = None self._limit = None self._use_cache = False - + def filter(self, **kwargs): """Returns a new query instance with the query arguments ANDed to the existing set""" @@ -83,31 +83,30 @@ class QuerySet(object): def order_by(self, *field_names): """Returns a new query instance with the ordering changed.""" return self._clone(_order_by=field_names) - + def select_related(self, true_or_false): """Returns a new query instance with the 'related' qualifier modified""" return self._clone(_related=true_or_false) - + def count(self): counter = self._clone() counter._order_by = [] - + # TODO - do we change these or not? # e.g. if someone does objects[0:10].count() - # (which + # (which #counter._offset = None #counter._limit = None counter._select_related = False _, sql, params = counter._get_sql_clause(True) cursor = connection.cursor() cursor.execute("SELECT COUNT(*)" + sql, params) - return cursor.fetchone()[0] + return cursor.fetchone()[0] # Convenience function for subclasses def _set_core_filter(self, **kwargs): """Sets the filters that should always be applied to queries""" self._filter = Q(**kwargs) - def _clone(self, **kwargs): """Gets a clone of the object, with optional kwargs to alter the clone""" @@ -121,26 +120,26 @@ class QuerySet(object): # restore cache self._result_cache = _result_cache_save return clone - + def _ensure_compatible(self, other): if self._distinct != other._distinct: raise ValueException, "Can't combine a unique query with a non-unique query" - + def _combine(self, other): self._ensure_compatible(other) # get a deepcopy of 'other's order by # (so that A.filter(args1) & A.filter(args2) does the same as # A.filter(args1).filter(args2) - combined = other._clone() + combined = other._clone() # If 'self' is ordered and 'other' isn't, propagate 'self's ordering if len(self._order_by) > 0 and len(combined._order_by == 0): combined._order_by = copy.deepcopy(self._order_by) return combined - + def extras(self, params=None, select=None, where=None, tables=None): return self._clone(_params=params, _select=select, _where=where, _tables=tables) - - def __and__(self, other): + + def __and__(self, other): combined = self._combine(other) combined._filter = self._filter & other._filter return combined @@ -149,7 +148,7 @@ class QuerySet(object): combined = self._combine(other) combined._filter = self._filter | other._filter return combined - + # TODO - allow_joins - do we need it? def _get_sql_clause(self, allow_joins): def quote_only_if_word(word): @@ -166,13 +165,13 @@ class QuerySet(object): select = ["%s.%s" % (backend.quote_name(opts.db_table), backend.quote_name(f.column)) for f in opts.fields] tables = [quote_only_if_word(t) for t in (self._tables or [])] - joins = SortedDict() + joins = SortedDict() where = self._where or [] params = self._params or [] # Convert the Q object into SQL. tables2, joins2, where2, params2 = self._filter.get_sql(opts) - + tables.extend(tables2) joins.update(joins2) where.extend(where2) @@ -238,8 +237,8 @@ class QuerySet(object): else: assert self._offset is None, "'offset' is not allowed without 'limit'" - return select, " ".join(sql), params - + return select, " ".join(sql), params + def _fetch_data(self): if self._use_cache: if self._result_cache is None: @@ -247,8 +246,7 @@ class QuerySet(object): return self._result_cache else: return list(self.get_iterator()) - - + def __iter__(self): """Gets an iterator for the data""" # Fetch the data or use get_iterator? If not, we can't @@ -256,13 +254,13 @@ class QuerySet(object): # Also, lots of things in current template system break if we # don't get it all. return iter(self._fetch_data()) - + def __len__(self): return len(self._fetch_data()) def __getitem__(self, k): """Retrieve an item or slice from the set of results""" - # getitem can't return query instances, because .filter() + # getitem can't return query instances, because .filter() # and .order_by() methods on the result would break badly. # This means we don't have to worry about arithmetic with # self._limit or self._offset - they will both be None @@ -270,7 +268,7 @@ class QuerySet(object): if isinstance(k, slice): # Get a new query if we haven't already got data from db if self._result_cache is None: - # slice.stop and slice.start + # slice.stop and slice.start clone = self._clone(_offset=k.start, _limit=k.stop) return list(clone)[::k.step] # TODO - we are throwing away this retrieved data. @@ -278,17 +276,17 @@ class QuerySet(object): # list structure we could put it in. else: return self._result_cache[k] - + else: # TODO: possibly use a new query which just gets one item # if we haven't already got them all? return self._fetch_data()[k] - + def get_iterator(self): # self._select is a dictionary, and dictionaries' key order is # undefined, so we convert it to a list of tuples. _extra_select = (self._select or {}).items() - + cursor = connection.cursor() select, sql, params = self._get_sql_clause(True) cursor.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params) @@ -306,7 +304,7 @@ class QuerySet(object): for i, k in enumerate(_extra_select): setattr(obj, k[0], row[index_end+i]) yield obj - + class QOperator: "Base class for QAnd and QOr" def __init__(self, *args): @@ -382,7 +380,6 @@ class Q: def get_sql(self, opts): return parse_lookup(self.kwargs.items(), opts) - def get_where_clause(lookup_type, table_prefix, field_name, value): if table_prefix.endswith('.'): table_prefix = backend.quote_name(table_prefix[:-1])+'.' @@ -453,19 +450,19 @@ def parse_lookup(kwarg_items, opts): # there for others to implement custom Q()s, etc that return other join # types. tables, joins, where, params = [], SortedDict(), [], [] - + for kwarg, value in kwarg_items: if value is None: pass - else: + else: path = kwarg.split(LOOKUP_SEPARATOR) # Extract the last elements of the kwarg. # The very-last is the clause (equals, like, etc). # The second-last is the table column on which the clause is # to be performed. # The exceptions to this are: - # 1) "pk", which is an implicit id__exact; - # if we find "pk", make the clause "exact', and insert + # 1) "pk", which is an implicit id__exact; + # if we find "pk", make the clause "exact', and insert # a dummy name of None, which we will replace when # we know which table column to grab as the primary key. # 2) If there is only one part, assume it to be an __exact @@ -476,7 +473,7 @@ def parse_lookup(kwarg_items, opts): elif len(path) == 0: path.append(clause) clause = 'exact' - + if len(path) < 1: raise TypeError, "Cannot parse keyword query %r" % kwarg