Ticket #10109: patch_django_10109.20090422.diff

django/db/models/sql/query.py

@@ -13 +13 @@
 from django.utils.datastructures import SortedDict
 from django.utils.encoding import force_unicode
 from django.db.backends.util import truncate_name
-from django.db import connection
+from django.db import connection, transaction
 from django.db.models import signals
 from django.db.models.fields import FieldDoesNotExist
 from django.db.models.query_utils import select_related_descend
@@ -2284 +2284 @@
         self.select = [(select_alias, select_col)]
         self.remove_inherited_models()
 
+    def _add_items(self, source_col_name, target_col_name, join_table, 
+                   pk_val, instance, field, *objs):
+        # join_table: name of the m2m link table
+        # source_col_name: the PK colname in join_table for the source object
+        # target_col_name: the PK colname in join_table for the target object
+        # *objs - objects to add. Either object instances, or primary keys of object instances.
+        
+        # If there aren't any objects, there is nothing to do.
+        if objs:
+            from django.db.models.base import Model
+            # Check that all the objects are of the right type
+            new_ids = set()
+            for obj in objs:
+                if isinstance(obj, self.model):
+                    new_ids.add(obj._get_pk_val())
+                elif isinstance(obj, Model):
+                    raise TypeError, "'%s' instance expected" % self.model._meta.object_name
+                else:
+                    new_ids.add(obj)
+            # Add the newly created or already existing objects to the join table.
+            # First find out which items are already added, to avoid adding them twice
+            cursor = connection.cursor()
+            cursor.execute("SELECT %s FROM %s WHERE %s = %%s AND %s IN (%s)" % \
+                (target_col_name, join_table, source_col_name,
+                target_col_name, ",".join(['%s'] * len(new_ids))),
+                [pk_val] + list(new_ids))
+            existing_ids = set([row[0] for row in cursor.fetchall()])
+        
+            # Add the ones that aren't there already
+            for obj_id in (new_ids - existing_ids):
+                cursor.execute("INSERT INTO %s (%s, %s) VALUES (%%s, %%s)" % \
+                    (join_table, source_col_name, target_col_name),
+                    [pk_val, obj_id])
+            transaction.commit_unless_managed()
+
+    def _remove_items(self, source_col_name, target_col_name, join_table, 
+                      pk_val, instance, field, *objs):
+        # source_col_name: the PK colname in join_table for the source object
+        # target_col_name: the PK colname in join_table for the target object
+        # *objs - objects to remove
+        
+        # If there aren't any objects, there is nothing to do.
+        if objs:
+            # Check that all the objects are of the right type
+            old_ids = set()
+            for obj in objs:
+                if isinstance(obj, self.model):
+                    old_ids.add(obj._get_pk_val())
+                else:
+                    old_ids.add(obj)
+            # Remove the specified objects from the join table
+            cursor = connection.cursor()
+            cursor.execute("DELETE FROM %s WHERE %s = %%s AND %s IN (%s)" % \
+                (join_table, source_col_name,
+                target_col_name, ",".join(['%s'] * len(old_ids))),
+                [pk_val] + list(old_ids))
+            transaction.commit_unless_managed()
+    
+    def _clear_items(self, source_col_name, join_table, pk_val, instance, 
+                     field):
+        # source_col_name: the PK colname in join_table for the source object
+        cursor = connection.cursor()
+        cursor.execute("DELETE FROM %s WHERE %s = %%s" % \
+            (join_table, source_col_name),
+            [pk_val])
+        transaction.commit_unless_managed()
+
     def execute_sql(self, result_type=MULTI):
         """
         Run the query against the database and returns the result(s). The

django/db/models/fields/related.py

@@ -1 @@
-from django.db import connection, transaction
+from django.db import connection
 from django.db.backends import util
 from django.db.models import signals, get_model
 from django.db.models.fields import AutoField, Field, IntegerField, PositiveIntegerField, PositiveSmallIntegerField, FieldDoesNotExist
@@ -382 +382 @@
     and adds behavior for many-to-many related objects."""
     class ManyRelatedManager(superclass):
         def __init__(self, model=None, core_filters=None, instance=None, symmetrical=None,
-                join_table=None, source_col_name=None, target_col_name=None):
+                join_table=None, source_col_name=None, target_col_name=None, field=None):
             super(ManyRelatedManager, self).__init__()
             self.core_filters = core_filters
             self.model = model
@@ -391 +391 @@
             self.join_table = join_table
             self.source_col_name = source_col_name
             self.target_col_name = target_col_name
+            self.field = field
             self.through = through
             self._pk_val = self.instance._get_pk_val()
             if self._pk_val is None:
@@ -403 +404 @@
         # the add and remove methods do not exist.
         if through is None:
             def add(self, *objs):
-                self._add_items(self.source_col_name, self.target_col_name, *objs)
+                self.get_query_set()._add_items(self.source_col_name,
+                                                self.target_col_name,
+                                                self.join_table,
+                                                self._pk_val,
+                                                self.instance,
+                                                self.field, 
+                                                *objs)
 
                 # If this is a symmetrical m2m relation to self, add the mirror entry in the m2m table
                 if self.symmetrical:
-                    self._add_items(self.target_col_name, self.source_col_name, *objs)
+                    self.get_query_set()._add_items(self.target_col_name,
+                                                    self.source_col_name,
+                                                    self.join_table,
+                                                    self._pk_val,
+                                                    self.instance,
+                                                    self.field, 
+                                                    *objs)
             add.alters_data = True
 
             def remove(self, *objs):
-                self._remove_items(self.source_col_name, self.target_col_name, *objs)
+                self.get_query_set()._remove_items(self.source_col_name, 
+                                                   self.target_col_name,
+                                                   self.join_table,
+                                                   self._pk_val,
+                                                   self.instance, 
+                                                   self.field, 
+                                                   *objs)
 
                 # If this is a symmetrical m2m relation to self, remove the mirror entry in the m2m table
                 if self.symmetrical:
-                    self._remove_items(self.target_col_name, self.source_col_name, *objs)
+                    self.get_query_set()._remove_items(self.target_col_name, 
+                                                       self.source_col_name,
+                                                       self.join_table,
+                                                       self._pk_val,
+                                                       self.instance, 
+                                                       self.field, 
+                                                       *objs)
             remove.alters_data = True
 
         def clear(self):
-            self._clear_items(self.source_col_name)
+            self.get_query_set()._clear_items(self.source_col_name,
+                                              self.join_table,
+                                              self._pk_val,
+                                              self.instance, 
+                                              self.field)
 
             # If this is a symmetrical m2m relation to self, clear the mirror entry in the m2m table
             if self.symmetrical:
-                self._clear_items(self.target_col_name)
+                self.get_query_set()._clear_items(self.target_col_name,
+                                                  self.join_table,
+                                                  self._pk_val,
+                                                  self.instance, 
+                                                  self.field)
         clear.alters_data = True
 
         def create(self, **kwargs):
@@ -446 +479 @@
             return obj, created
         get_or_create.alters_data = True
 
-        def _add_items(self, source_col_name, target_col_name, *objs):
-            # join_table: name of the m2m link table
-            # source_col_name: the PK colname in join_table for the source object
-            # target_col_name: the PK colname in join_table for the target object
-            # *objs - objects to add. Either object instances, or primary keys of object instances.
-
-            # If there aren't any objects, there is nothing to do.
-            if objs:
-                from django.db.models.base import Model
-                # Check that all the objects are of the right type
-                new_ids = set()
-                for obj in objs:
-                    if isinstance(obj, self.model):
-                        new_ids.add(obj._get_pk_val())
-                    elif isinstance(obj, Model):
-                        raise TypeError, "'%s' instance expected" % self.model._meta.object_name
-                    else:
-                        new_ids.add(obj)
-                # Add the newly created or already existing objects to the join table.
-                # First find out which items are already added, to avoid adding them twice
-                cursor = connection.cursor()
-                cursor.execute("SELECT %s FROM %s WHERE %s = %%s AND %s IN (%s)" % \
-                    (target_col_name, self.join_table, source_col_name,
-                    target_col_name, ",".join(['%s'] * len(new_ids))),
-                    [self._pk_val] + list(new_ids))
-                existing_ids = set([row[0] for row in cursor.fetchall()])
-
-                # Add the ones that aren't there already
-                for obj_id in (new_ids - existing_ids):
-                    cursor.execute("INSERT INTO %s (%s, %s) VALUES (%%s, %%s)" % \
-                        (self.join_table, source_col_name, target_col_name),
-                        [self._pk_val, obj_id])
-                transaction.commit_unless_managed()
-
-        def _remove_items(self, source_col_name, target_col_name, *objs):
-            # source_col_name: the PK colname in join_table for the source object
-            # target_col_name: the PK colname in join_table for the target object
-            # *objs - objects to remove
-
-            # If there aren't any objects, there is nothing to do.
-            if objs:
-                # Check that all the objects are of the right type
-                old_ids = set()
-                for obj in objs:
-                    if isinstance(obj, self.model):
-                        old_ids.add(obj._get_pk_val())
-                    else:
-                        old_ids.add(obj)
-                # Remove the specified objects from the join table
-                cursor = connection.cursor()
-                cursor.execute("DELETE FROM %s WHERE %s = %%s AND %s IN (%s)" % \
-                    (self.join_table, source_col_name,
-                    target_col_name, ",".join(['%s'] * len(old_ids))),
-                    [self._pk_val] + list(old_ids))
-                transaction.commit_unless_managed()
-
-        def _clear_items(self, source_col_name):
-            # source_col_name: the PK colname in join_table for the source object
-            cursor = connection.cursor()
-            cursor.execute("DELETE FROM %s WHERE %s = %%s" % \
-                (self.join_table, source_col_name),
-                [self._pk_val])
-            transaction.commit_unless_managed()
-
     return ManyRelatedManager
 
 class ManyRelatedObjectsDescriptor(object):
@@ -585 +554 @@
             symmetrical=(self.field.rel.symmetrical and isinstance(instance, rel_model)),
             join_table=qn(self.field.m2m_db_table()),
             source_col_name=qn(self.field.m2m_column_name()),
-            target_col_name=qn(self.field.m2m_reverse_name())
+            target_col_name=qn(self.field.m2m_reverse_name()),
+            field=self.field
         )
 
         return manager

django/db/models/query.py

@@ -683 +683 @@
         obj = self.values("pk")
         return obj.query.as_nested_sql()
 
+    ################################################
+    # PRIVATE METHODS THAT DEAL WITH M2M RELATIONS #
+    ################################################
+    
+    def _add_items(self, source_col_name=None, target_col_name=None,
+                   join_table=None, pk_val=None, 
+                   instance=None, field=None, *objs):
+        self.query._add_items(source_col_name, target_col_name,
+                              join_table, pk_val,instance, field, *objs)
+
+    def _remove_items(self, source_col_name=None, target_col_name=None, 
+                      join_table=None, pk_val=None,
+                      instance=None, field=None, *objs):
+        self.query._remove_items(source_col_name, target_col_name,
+                                 join_table, pk_val, instance, field, *objs)
+
+    def _clear_items(self, source_col_name=None, join_table=None, pk_val=None, 
+                     instance=None, field=None):
+        self.query._clear_items(source_col_name, join_table, pk_val, instance, 
+                                field)
+
     # When used as part of a nested query, a queryset will never be an "always
     # empty" result.
     value_annotation = True