Context Navigation

Ticket #11402: exists.2.diff

File exists.2.diff, 5.4 KB (added by Alex Gaynor, 15 years ago)
Fixed docs and made has_results() work more like get_count(). This doesn't need tests because it is trivially shown to work because forms and save() continue to work (which are both tested extensively).

diff --git a/django/contrib/admin/validation.py b/django/contrib/admin/validation.py
index 05e5c6d..595b951 100644

                def validate(cls, model):
 def validate_inline(cls, parent, parent_model):
+    fk = _get_foreign_key(parent_model, cls.model, fk_name=cls.fk_name, can_fail=True)
     # model is already verified to exist and be a Model
     if cls.fk_name: # default value is None
         f = get_field(cls, cls.model, cls.model._meta, 'fk_name', cls.fk_name)
         if not isinstance(f, models.ForeignKey):
             raise ImproperlyConfigured("'%s.fk_name is not an instance of "
                     "models.ForeignKey." % cls.__name__)
-    fk = _get_foreign_key(parent_model, cls.model, fk_name=cls.fk_name, can_fail=True)
     # extra = 3
     # max_num = 0
     for attr in ('extra', 'max_num'):

diff --git a/django/db/models/base.py b/django/db/models/base.py
index a5c9986..30b12da 100644

                class Model(object):
             if pk_set:
                 # Determine whether a record with the primary key already exists.
                 if (force_update or (not force_insert and
                         manager.filter(pk=pk_val).extra(select={'a': 1}).values('a').order_by())):
+                        manager.filter(pk=pk_val).exists())):
                     # It does already exist, so do an UPDATE.
                     if force_update or non_pks:
                         values = [(f, None, (raw and getattr(self, f.attname) or f.pre_save(self, False))) for f in non_pks]

diff --git a/django/db/models/manager.py b/django/db/models/manager.py
index 52612d8..73d2bf5 100644

                class Manager(object):
     def only(self, *args, **kwargs):
         return self.get_query_set().only(*args, **kwargs)
+    def exists(self, *args, **kwargs):
+        return self.get_query_ste().exists(*args, **kwargs)
     def _insert(self, values, **kwargs):
         return insert_query(self.model, values, **kwargs)

diff --git a/django/db/models/query.py b/django/db/models/query.py
index 46a86fc..02288c1 100644

                class QuerySet(object):
         self._result_cache = None
         return query.execute_sql(None)
     _update.alters_data = True
+    def exists(self):
+        if self._result_cache is None:
+            return self.query.has_results()
+        return bool(self._result_cache)
     ##################################################
     # PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS #

diff --git a/django/db/models/sql/query.py b/django/db/models/sql/query.py
index 23f99e4..ad0998b 100644

                class BaseQuery(object):
             number = min(number, self.high_mark - self.low_mark)
         return number
+    def has_results(self):
+        """
+        Returns whether or not there are any items in the result set this Query
+        represents.  Does this in a super tricking way.  Basically the
+        equivalent of QuerySet.extra(select={'a': 1}).values('a').order_by()
+        to maximize efficiency.
+        """
+        c = self.clone()
+        c.add_extra({'a': 1}, None, None, None, None, None)
+        c.add_fields(())
+        c.set_extra_mask(('a',))
+        c.set_aggregate_mask(())
+        c.clear_ordering()
+        results = self.execute_sql()
+        return bool(results)
     def as_sql(self, with_limits=True, with_col_aliases=False):
         """

diff --git a/django/forms/models.py b/django/forms/models.py
index cc43612..37fce68 100644

                class BaseModelForm(BaseForm):
             if self.instance.pk is not None:
                 qs = qs.exclude(pk=self.instance.pk)
+            # This cute trick with extra/values is the most efficient way to
+            # tell if a particular query returns any results.
+            if qs.extra(select={'a': 1}).values('a').order_by():
+            if qs.exists():
                 if len(unique_check) == 1:
                     self._errors[unique_check[0]] = ErrorList([self.unique_error_message(unique_check)])
                 else:
-…
+               class BaseModelForm(BaseForm):
             if self.instance.pk is not None:
                 qs = qs.exclude(pk=self.instance.pk)
+            # This cute trick with extra/values is the most efficient way to
+            # tell if a particular query returns any results.
+            if qs.extra(select={'a': 1}).values('a').order_by():
+            if qs.exists():
                 self._errors[field] = ErrorList([
                     self.date_error_message(lookup_type, field, unique_for)
                 ])

diff --git a/docs/ref/models/querysets.txt b/docs/ref/models/querysets.txt
index efd7c54..26c76ca 100644

                Aggregation <topics-db-aggregation>`.
 .. _field-lookups:
+``exists()``
+~~~~~~~~~~~~
+Returns whether or not there are any items in the ``QuerySet``.  This will
+perform the query in the most efficient way possible.
 Field lookups
 -------------