diff --git a/django/contrib/auth/models.py b/django/contrib/auth/models.py index eb39868..fb5ad10 100644 --- a/django/contrib/auth/models.py +++ b/django/contrib/auth/models.py @@ -408,8 +408,8 @@ class AnonymousUser(object): is_staff = False is_active = False is_superuser = False - _groups = EmptyManager() - _user_permissions = EmptyManager() + _groups = EmptyManager(model=User) + _user_permissions = EmptyManager(model=User) def __init__(self): pass diff --git a/django/db/models/manager.py b/django/db/models/manager.py index e1bbf6e..28a320a 100644 --- a/django/db/models/manager.py +++ b/django/db/models/manager.py @@ -1,6 +1,6 @@ import copy from django.db import router -from django.db.models.query import QuerySet, EmptyQuerySet, insert_query, RawQuerySet +from django.db.models.query import QuerySet, insert_query, RawQuerySet from django.db.models import signals from django.db.models.fields import FieldDoesNotExist @@ -46,10 +46,10 @@ class Manager(object): # Tracks each time a Manager instance is created. Used to retain order. creation_counter = 0 - def __init__(self): + def __init__(self, model=None): super(Manager, self).__init__() self._set_creation_counter() - self.model = None + self.model = model self._inherited = False self._db = None @@ -101,7 +101,7 @@ class Manager(object): ####################### def get_empty_query_set(self): - return EmptyQuerySet(self.model, using=self._db) + return QuerySet(self.model, using=self.db).none() def get_query_set(self): """Returns a new QuerySet object. Subclasses can override this method diff --git a/django/db/models/query.py b/django/db/models/query.py index 41c24c7..0d91ce9 100644 --- a/django/db/models/query.py +++ b/django/db/models/query.py @@ -31,7 +31,6 @@ class QuerySet(object): """ def __init__(self, model=None, query=None, using=None): self.model = model - # EmptyQuerySet instantiates QuerySet with model as None self._db = using self.query = query or sql.Query(self.model) self._result_cache = None @@ -210,8 +209,6 @@ class QuerySet(object): def __and__(self, other): self._merge_sanity_check(other) - if isinstance(other, EmptyQuerySet): - return other._clone() combined = self._clone() combined.query.combine(other.query, sql.AND) return combined @@ -219,8 +216,6 @@ class QuerySet(object): def __or__(self, other): self._merge_sanity_check(other) combined = self._clone() - if isinstance(other, EmptyQuerySet): - return combined combined.query.combine(other.query, sql.OR) return combined @@ -600,7 +595,9 @@ class QuerySet(object): """ Returns an empty QuerySet. """ - return self._clone(klass=EmptyQuerySet) + c = self._clone() + c.query.set_empty() + return c ################################################################## # PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET # @@ -1116,127 +1113,6 @@ class DateQuerySet(QuerySet): c._setup_query() return c - -class EmptyQuerySet(QuerySet): - def __init__(self, model=None, query=None, using=None): - super(EmptyQuerySet, self).__init__(model, query, using) - self._result_cache = [] - - def __and__(self, other): - return self._clone() - - def __or__(self, other): - return other._clone() - - def count(self): - return 0 - - def delete(self): - pass - - def _clone(self, klass=None, setup=False, **kwargs): - c = super(EmptyQuerySet, self)._clone(klass, setup=setup, **kwargs) - c._result_cache = [] - return c - - def iterator(self): - # This slightly odd construction is because we need an empty generator - # (it raises StopIteration immediately). - yield iter([]).next() - - def all(self): - """ - Always returns EmptyQuerySet. - """ - return self - - def filter(self, *args, **kwargs): - """ - Always returns EmptyQuerySet. - """ - return self - - def exclude(self, *args, **kwargs): - """ - Always returns EmptyQuerySet. - """ - return self - - def complex_filter(self, filter_obj): - """ - Always returns EmptyQuerySet. - """ - return self - - def select_related(self, *fields, **kwargs): - """ - Always returns EmptyQuerySet. - """ - return self - - def annotate(self, *args, **kwargs): - """ - Always returns EmptyQuerySet. - """ - return self - - def order_by(self, *field_names): - """ - Always returns EmptyQuerySet. - """ - return self - - def distinct(self, fields=None): - """ - Always returns EmptyQuerySet. - """ - return self - - def extra(self, select=None, where=None, params=None, tables=None, - order_by=None, select_params=None): - """ - Always returns EmptyQuerySet. - """ - assert self.query.can_filter(), \ - "Cannot change a query once a slice has been taken" - return self - - def reverse(self): - """ - Always returns EmptyQuerySet. - """ - return self - - def defer(self, *fields): - """ - Always returns EmptyQuerySet. - """ - return self - - def only(self, *fields): - """ - Always returns EmptyQuerySet. - """ - return self - - def update(self, **kwargs): - """ - Don't update anything. - """ - return 0 - - def aggregate(self, *args, **kwargs): - """ - Return a dict mapping the aggregate names to None - """ - for arg in args: - kwargs[arg.default_alias] = arg - return dict([(key, None) for key in kwargs]) - - # EmptyQuerySet is always an empty result in where-clauses (and similar - # situations). - value_annotation = False - def get_klass_info(klass, max_depth=0, cur_depth=0, requested=None, only_load=None, local_only=False): """ diff --git a/django/db/models/sql/compiler.py b/django/db/models/sql/compiler.py index 72948f9..6808b34 100644 --- a/django/db/models/sql/compiler.py +++ b/django/db/models/sql/compiler.py @@ -60,7 +60,6 @@ class SQLCompiler(object): """ if with_limits and self.query.low_mark == self.query.high_mark: return '', () - self.pre_sql_setup() # After executing the query, we must get rid of any joins the query # setup created. So, take note of alias counts before the query ran. diff --git a/django/db/models/sql/query.py b/django/db/models/sql/query.py index a78df34..825647d 100644 --- a/django/db/models/sql/query.py +++ b/django/db/models/sql/query.py @@ -22,7 +22,7 @@ from django.db.models.sql.constants import * from django.db.models.sql.datastructures import EmptyResultSet, Empty, MultiJoin from django.db.models.sql.expressions import SQLEvaluator from django.db.models.sql.where import (WhereNode, Constraint, EverythingNode, - ExtraWhere, AND, OR) + ExtraWhere, AND, OR, NothingNode) from django.core.exceptions import FieldError __all__ = ['Query', 'RawQuery'] @@ -426,6 +426,13 @@ class Query(object): return number + def set_empty(self): + """ + Turn this queryset into one which will return nothing when evaluated. + """ + self.where = self.where_class() + self.where.add(NothingNode(), AND) + def has_results(self, using): q = self.clone() q.add_extra({'a': 1}, None, None, None, None, None) diff --git a/django/db/models/sql/where.py b/django/db/models/sql/where.py index 1455ba6..36cf82d 100644 --- a/django/db/models/sql/where.py +++ b/django/db/models/sql/where.py @@ -36,6 +36,9 @@ class WhereNode(tree.Node): """ default = AND + def __init__(self, *args, **kwargs): + super(WhereNode, self).__init__(*args, **kwargs) + def add(self, data, connector): """ Add a node to the where-tree. If the data is a list or tuple, it is @@ -252,6 +255,7 @@ class WhereNode(tree.Node): if hasattr(child[3], 'relabel_aliases'): child[3].relabel_aliases(change_map) + class EverythingNode(object): """ A node that matches everything. diff --git a/docs/ref/models/querysets.txt b/docs/ref/models/querysets.txt index 103cae1..886cbf6 100644 --- a/docs/ref/models/querysets.txt +++ b/docs/ref/models/querysets.txt @@ -601,8 +601,8 @@ none .. method:: none() -Returns an ``EmptyQuerySet`` — a ``QuerySet`` subclass that always evaluates to -an empty list. This can be used in cases where you know that you should return +Returns a ``QuerySet`` that always evaluates to an empty list. No query should +be executed. This can be used in cases where you know that you should return an empty result set and your caller is expecting a ``QuerySet`` object (instead of returning an empty list, for example.) diff --git a/tests/modeltests/get_object_or_404/tests.py b/tests/modeltests/get_object_or_404/tests.py index 280720f..992a2f3 100644 --- a/tests/modeltests/get_object_or_404/tests.py +++ b/tests/modeltests/get_object_or_404/tests.py @@ -53,7 +53,7 @@ class GetObjectOr404Tests(TestCase): get_object_or_404, Author.objects.all() ) - # Using an EmptyQuerySet raises a Http404 error. + # Using a empty queryset raises a Http404 error. self.assertRaises(Http404, get_object_or_404, Article.objects.none(), title__contains="Run" ) diff --git a/tests/modeltests/lookup/tests.py b/tests/modeltests/lookup/tests.py index 3571e21..5333402 100644 --- a/tests/modeltests/lookup/tests.py +++ b/tests/modeltests/lookup/tests.py @@ -436,7 +436,7 @@ class LookupTests(TestCase): ]) def test_none(self): - # none() returns an EmptyQuerySet that behaves like any other QuerySet object + # none() returns an empty queryset that behaves like any other QuerySet object self.assertQuerysetEqual(Article.objects.none(), []) self.assertQuerysetEqual( Article.objects.none().filter(headline__startswith='Article'), []) diff --git a/tests/regressiontests/queries/tests.py b/tests/regressiontests/queries/tests.py index ded3e8f..a706c82 100644 --- a/tests/regressiontests/queries/tests.py +++ b/tests/regressiontests/queries/tests.py @@ -8,7 +8,7 @@ from django.conf import settings from django.core.exceptions import FieldError from django.db import DatabaseError, connection, connections, DEFAULT_DB_ALIAS from django.db.models import Count -from django.db.models.query import Q, ITER_CHUNK_SIZE, EmptyQuerySet +from django.db.models.query import Q, ITER_CHUNK_SIZE from django.test import TestCase, skipUnlessDBFeature from django.utils import unittest from django.utils.datastructures import SortedDict @@ -655,31 +655,6 @@ class Queries1Tests(BaseQuerysetTest): ['', ''] ) - def test_ticket7235(self): - # An EmptyQuerySet should not raise exceptions if it is filtered. - q = EmptyQuerySet() - self.assertQuerysetEqual(q.all(), []) - self.assertQuerysetEqual(q.filter(x=10), []) - self.assertQuerysetEqual(q.exclude(y=3), []) - self.assertQuerysetEqual(q.complex_filter({'pk': 1}), []) - self.assertQuerysetEqual(q.select_related('spam', 'eggs'), []) - self.assertQuerysetEqual(q.annotate(Count('eggs')), []) - self.assertQuerysetEqual(q.order_by('-pub_date', 'headline'), []) - self.assertQuerysetEqual(q.distinct(), []) - self.assertQuerysetEqual( - q.extra(select={'is_recent': "pub_date > '2006-01-01'"}), - [] - ) - q.query.low_mark = 1 - self.assertRaisesMessage( - AssertionError, - 'Cannot change a query once a slice has been taken', - q.extra, select={'is_recent': "pub_date > '2006-01-01'"} - ) - self.assertQuerysetEqual(q.reverse(), []) - self.assertQuerysetEqual(q.defer('spam', 'eggs'), []) - self.assertQuerysetEqual(q.only('spam', 'eggs'), []) - def test_ticket7791(self): # There were "issues" when ordering and distinct-ing on fields related # via ForeignKeys. @@ -1613,7 +1588,7 @@ class CloneTests(TestCase): class EmptyQuerySetTests(TestCase): def test_emptyqueryset_values(self): - # #14366 -- Calling .values() on an EmptyQuerySet and then cloning that + # #14366 -- Calling .values() on an empty queryset and then cloning that # should not cause an error" self.assertQuerysetEqual( Number.objects.none().values('num').order_by('num'), []