Django

Code

Changeset 7169

Show
Ignore:
Timestamp:
02/27/08 20:49:31 (9 months ago)
Author:
mtredinnick
Message:

queryset-refactor: Fixed a few really silly errors in the Q class and negation
handling in the tree class. Discovered whilst starting to fix exclude().

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • django/branches/queryset-refactor/django/db/models/query.py

    r7165 r7169  
    33from django.db import connection, transaction 
    44from django.db.models.fields import DateField, FieldDoesNotExist 
    5 from django.db.models.query_utils import Q, QNot, EmptyResultSet 
     5from django.db.models.query_utils import Q, EmptyResultSet, not_q 
    66from django.db.models import signals, sql 
    77from django.dispatch import dispatcher 
    …… 
    317317        set. 
    318318        """ 
    319         return self._filter_or_exclude(QNot, *args, **kwargs) 
     319        return self._filter_or_exclude(not_q, *args, **kwargs) 
    320320 
    321321    def _filter_or_exclude(self, mapper, *args, **kwargs): 
    …… 
    592592        yield iter([]).next() 
    593593 
    594 # QOperator, QAnd and QOr are temporarily retained for backwards compatibility. 
    595 # All the old functionality is now part of the 'Q' class. 
     594# QOperator, QNot, QAnd and QOr are temporarily retained for backwards 
     595# compatibility. All the old functionality is now part of the 'Q' class. 
    596596class QOperator(Q): 
    597597    def __init__(self, *args, **kwargs): 
    598598        warnings.warn('Use Q instead of QOr, QAnd or QOperation.', 
    599599                DeprecationWarning, stacklevel=2) 
     600        super(QOperator, self).__init__(*args, **kwargs) 
    600601 
    601602QOr = QAnd = QOperator 
     603 
     604def QNot(q): 
     605    warnings.warn('Use ~q instead of QNot(q)', DeprecationWarning, stacklevel=2) 
     606    return ~q 
    602607 
    603608def get_cached_row(klass, row, index_start, max_depth=0, cur_depth=0, 

  • django/branches/queryset-refactor/django/db/models/query_utils.py

    r6518 r7169  
    55modules without getting into circular import difficulties. 
    66""" 
     7 
     8from copy import deepcopy 
     9 
    710from django.utils import tree 
    811 
    …… 
    3235        if not isinstance(other, Q): 
    3336            raise TypeError(other) 
    34         self.add(other, conn) 
    35         return self 
     37        obj = deepcopy(self) 
     38        obj.add(other, conn) 
     39        return obj 
    3640 
    3741    def __or__(self, other): 
    …… 
    4246 
    4347    def __invert__(self): 
    44         return QNot(self) 
     48        obj = deepcopy(self) 
     49        obj.negate() 
     50        return obj 
    4551 
    46 class QNot(Q): 
    47     """ 
    48     Encapsulates the negation of a Q object. 
    49     """ 
    50     def __init__(self, q): 
    51         """Creates the negation of the Q object passed in.""" 
    52         super(QNot, self).__init__() 
    53         self.add(q, self.AND) 
    54         self.negate() 
     52def not_q(q): 
     53    return ~q 
    5554 
    56     def __invert__(self): 
    57         return self.children[0] 
    58  

  • django/branches/queryset-refactor/django/db/models/sql/where.py

    r7088 r7169  
    5050                elif isinstance(child, tree.Node): 
    5151                    sql, params = self.as_sql(child, qn) 
    52                     if child.negated: 
    53                         format = 'NOT (%s)' 
     52                    if len(child.children) == 1: 
     53                        format = '%s' 
    5454                    else: 
    5555                        format = '(%s)' 
     56                    if child.negated: 
     57                        format = 'NOT %s' % format 
    5658                else: 
    5759                    sql, params = self.make_atom(child, qn) 

  • django/branches/queryset-refactor/django/utils/tree.py

    r6957 r7169  
    44""" 
    55 
    6 import copy 
     6from copy import deepcopy 
    77 
    88class Node(object): 
    …… 
    1616    default = 'DEFAULT' 
    1717 
    18     def __init__(self, children=None, connector=None): 
     18    def __init__(self, children=None, connector=None, negated=False): 
    1919        self.children = children and children[:] or [] 
    2020        self.connector = connector or self.default 
    2121        self.subtree_parents = [] 
    22         self.negated = False 
     22        self.negated = negated 
    2323 
    2424    def __str__(self): 
     25        if self.negated: 
     26            return '(NOT (%s: %s))' % (self.connector, ', '.join([str(c) for c 
     27                    in self.children])) 
    2528        return '(%s: %s)' % (self.connector, ', '.join([str(c) for c in 
    26             self.children])) 
     29                self.children])) 
    2730 
    2831    def __deepcopy__(self, memodict): 
    …… 
    3033        Utility method used by copy.deepcopy(). 
    3134        """ 
    32         obj = self.__class__(connector=self.connector) 
    33         obj.children = copy.deepcopy(self.children, memodict) 
    34         obj.subtree_parents = copy.deepcopy(self.subtree_parents, memodict) 
    35         obj.negated = self.negated 
     35        obj = Node(connector=self.connector, negated=self.negated) 
     36        obj.__class__ = self.__class__ 
     37        obj.children = deepcopy(self.children, memodict) 
     38        obj.subtree_parents = deepcopy(self.subtree_parents, memodict) 
    3639        return obj 
    3740 
    …… 
    6467            self.connector = conn_type 
    6568        if self.connector == conn_type: 
    66             if isinstance(node, Node) and (node.connector == conn_type 
    67                     or len(node) == 1): 
     69            if isinstance(node, Node) and (node.connector == conn_type or 
     70                    len(node) == 1): 
    6871                self.children.extend(node.children) 
    6972            else: 
    7073                self.children.append(node) 
    7174        else: 
    72             obj = Node(self.children, self.connector) 
     75            obj = Node(self.children, self.connector, self.negated) 
    7376            self.connector = conn_type 
    7477            self.children = [obj, node] 
    …… 
    8184        method is useful for implementing "not" arrangements. 
    8285        """ 
    83         self.children = [NegatedNode(self.children, self.connector, 
    84                 old_state=self.negated)] 
     86        self.children = [Node(self.children, self.connector, not self.negated)] 
    8587        self.connector = self.default 
    8688 
    …… 
    9496            self.connector = conn_type 
    9597        elif self.connector != conn_type: 
    96             self.children = [Node(self.children, self.connector)] 
     98            self.children = [Node(self.children, self.connector, self.negated)] 
    9799            self.connector = conn_type 
     100            self.negated = False 
    98101 
    99         self.subtree_parents.append(Node(self.children, self.connector)) 
     102        self.subtree_parents.append(Node(self.children, self.connector, 
     103                self.negated)) 
    100104        self.connector = self.default 
     105        self.negated = False 
    101106        self.children = [] 
    102107 
    …… 
    111116        node = Node(self.children, self.connector) 
    112117        self.connector = obj.connector 
     118        self.negated = obj.negated 
    113119        self.children = obj.children 
    114120        self.children.append(node) 
    115121 
    116 class NegatedNode(Node): 
    117     """ 
    118     A class that indicates the connector type should be negated (whatever that 
    119     means -- it's up to the client) when used by the client code. 
    120     """ 
    121     def __init__(self, children=None, connector=None, old_state=True): 
    122         super(NegatedNode, self).__init__(children, connector) 
    123         self.negated = not old_state 
    124