Changeset 1508

Timestamp:

11/30/05 00:14:05 (3 years ago)

Author:

adrian

Message:

Fixed #251 -- Added OR support to queries, via the new 'complex' DB API keyword argument. Updated docs and added unit tests. Also removed old, undocumented '_or' parameter. Thanks, Hugo.

Files:

• django/trunk/django/contrib/admin/views/main.py (modified) (1 diff)
• django/trunk/django/core/meta/__init__.py (modified) (2 diffs)
• django/trunk/docs/db-api.txt (modified) (1 diff)
• django/trunk/tests/testapp/models/__init__.py (modified) (1 diff)
• django/trunk/tests/testapp/models/or_lookups.py (added)

django/trunk/django/contrib/admin/views/main.py

@@ -217 +217 @@
-        lookup_params['order_by'] = ((order_type == 'desc' and '-' or '') + lookup_order_field,)
-        if lookup_opts.admin.search_fields and query:
-or
+complex
-            for bit in query.split():
-y
+ies
-                for field_name in lookup_opts.admin.search_fields:
-
-
-
-
+
+
+
-        if opts.one_to_one_field:
-            lookup_params.update(opts.one_to_one_field.rel.limit_choices_to)
-        self.lookup_params = lookup_params
-
-
-def change_list(request, app_label, module_name):

django/trunk/django/core/meta/__init__.py

@@ -282 +282 @@
-            rel_obj_name = '%s_%s' % (self.opts.app_label, rel_obj_name)
-        return rel_obj_name
+
+class QBase:
+    "Base class for QAnd and QOr"
+    def __init__(self, *args):
+        self.args = args
+
+    def __repr__(self):
+        return '(%s)' % self.operator.join([repr(el) for el in self.args])
+
+    def get_sql(self, opts, table_count):
+        tables, join_where, where, params = [], [], [], []
+        for val in self.args:
+            tables2, join_where2, where2, params2, table_count = val.get_sql(opts, table_count)
+            tables.extend(tables2)
+            join_where.extend(join_where2)
+            where.extend(where2)
+            params.extend(params2)
+        return tables, join_where, ['(%s)' % self.operator.join(where)], params, table_count
+
+class QAnd(QBase):
+    "Encapsulates a combined query that uses 'AND'."
+    operator = ' AND '
+    def __or__(self, other):
+        if isinstance(other, (QAnd, QOr, Q)):
+            return QOr(self, other)
+        else:
+            raise TypeError, other
+
+    def __and__(self, other):
+        if isinstance(other, QAnd):
+            return QAnd(*(self.args+other.args))
+        elif isinstance(other, (Q, QOr)):
+            return QAnd(*(self.args+(other,)))
+        else:
+            raise TypeError, other
+
+class QOr(QBase):
+    "Encapsulates a combined query that uses 'OR'."
+    operator = ' OR '
+    def __and__(self, other):
+        if isinstance(other, (QAnd, QOr, Q)):
+            return QAnd(self, other)
+        else:
+            raise TypeError, other
+
+    def __or__(self, other):
+        if isinstance(other, QOr):
+            return QOr(*(self.args+other.args))
+        elif isinstance(other, (Q, QAnd)):
+            return QOr(*(self.args+(other,)))
+        else:
+            raise TypeError, other
+
+class Q:
+    "Encapsulates queries for the 'complex' parameter to Django API functions."
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+
+    def __repr__(self):
+        return 'Q%r' % self.kwargs
+
+    def __and__(self, other):
+        if isinstance(other, (Q, QAnd, QOr)):
+            return QAnd(self, other)
+        else:
+            raise TypeError, other
+
+    def __or__(self, other):
+        if isinstance(other, (Q, QAnd, QOr)):
+            return QOr(self, other)
+        else:
+            raise TypeError, other
+
+    def get_sql(self, opts, table_count):
+        return _parse_lookup(self.kwargs.items(), opts, table_count)
-
-class Options:
@@ -1390 +1465 @@
-            continue
-        if kwarg_value is None:
+            continue
+        if kwarg == 'complex':
+            tables2, join_where2, where2, params2, table_count = kwarg_value.get_sql(opts, table_count)
+            tables.extend(tables2)
+            join_where.extend(join_where2)
+            where.extend(where2)
+            params.extend(params2)
-            continue
-        if kwarg == '_or':

django/trunk/docs/db-api.txt

@@ -220 +220 @@
-.. _`Keyword Arguments`: http://docs.python.org/tut/node6.html#SECTION006720000000000000000
-
+OR lookups
+----------
+
+**New in Django development version.**
+
+By default, multiple lookups are "AND"ed together. If you'd like to use ``OR``
+statements in your queries, use the ``complex`` lookup type.
+
+``complex`` takes an expression of clauses, each of which is an instance of
+``django.core.meta.Q``. ``Q`` takes an arbitrary number of keyword arguments in
+the standard Django lookup format. And you can use Python's "and" (``&``) and
+"or" (``|``) operators to combine ``Q`` instances. For example::
+
+    from django.core.meta import Q
+    polls.get_object(complex=(Q(question__startswith='Who') | Q(question__startswith='What')))
+
+The ``|`` symbol signifies an "OR", so this (roughly) translates into::
+
+    SELECT * FROM polls
+    WHERE question LIKE 'Who%' OR question LIKE 'What%';
+
+You can use ``&`` and ``|`` operators together, and use parenthetical grouping.
+Example::
+
+    polls.get_object(complex=(Q(question__startswith='Who') & (Q(pub_date__exact=date(2005, 5, 2)) | pub_date__exact=date(2005, 5, 6)))
+
+This roughly translates into::
+
+    SELECT * FROM polls
+    WHERE question LIKE 'Who%'
+        AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06');
+
+See the `OR lookups examples page`_ for more examples.
+
+.. _OR lookups examples page: http://www.djangoproject.com/documentation/models/or_lookups/
+
-Ordering
-========

django/trunk/tests/testapp/models/__init__.py

@@ -2 +2 @@
-           'ordering', 'lookup', 'get_latest', 'm2m_intermediary', 'one_to_one',
-           'm2o_recursive', 'm2o_recursive2', 'save_delete_hooks', 'custom_pk',
-
+
+