Ticket #10109: patch_django_10109.20090123.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
-
+, transaction
-from django.db.models import signals
-from django.db.models.fields import FieldDoesNotExist
-from django.db.models.query_utils import select_related_descend
@@ -1921 +1921 @@
-            select_col = join_info[RHS_JOIN_COL]
-        self.select = [(select_alias, select_col)]
-
+    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:
+            # 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())
+                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 @@
-, transaction
+
-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
@@ -361 +361 @@
-    and adds behavior for many-to-many related objects."""
-    class ManyRelatedManager(superclass):
-        def __init__(self, model=None, core_filters=None, instance=None, symmetrical=None,
-
+, field=None
-            super(ManyRelatedManager, self).__init__()
-            self.core_filters = core_filters
-            self.model = model
@@ -370 +370 @@
-            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:
@@ -382 +383 @@
-        # the add and remove methods do not exist.
-        if through is None:
-            def add(self, *objs):
-
+
+
+
+
+
+
+
-
-                # If this is a symmetrical m2m relation to self, add the mirror entry in the m2m table
-                if self.symmetrical:
-
+
+
+
+
+
+
+
-            add.alters_data = True
-
-            def remove(self, *objs):
-
+
+
+
+
+
+
+
-
-                # If this is a symmetrical m2m relation to self, remove the mirror entry in the m2m table
-                if self.symmetrical:
-
+
+
+
+
+
+
+
-            remove.alters_data = True
-
-        def clear(self):
-
+
+
+
+
+
-
-            # If this is a symmetrical m2m relation to self, clear the mirror entry in the m2m table
-            if self.symmetrical:
-
+
+
+
+
+
-        clear.alters_data = True
-
-        def create(self, **kwargs):
@@ -425 +458 @@
-            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:
-                # 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())
-                    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):
@@ -561 +533 @@
-            symmetrical=(self.field.rel.symmetrical and instance.__class__ == rel_model),
-            join_table=qn(self.field.m2m_db_table()),
-            source_col_name=qn(self.field.m2m_column_name()),
-
+
+
-        )
-
-        return manager

django/db/models/query.py

@@ -710 +710 @@
-        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