Ticket #7539: on_delete_on_update-r10558.diff

db/models/base.py

@@ -13 +13 @@
-from django.db.models.fields import AutoField, FieldDoesNotExist
-from django.db.models.fields.related import OneToOneRel, ManyToOneRel, OneToOneField
-from django.db.models.query import delete_objects, Q
-
+CollectedFields, 
-from django.db.models.options import Options
-
+, IntegrityError
-from django.db.models import signals
+from django.db.models.fields.related import CASCADE, RESTRICT, SET_NULL
-from django.db.models.loading import register_models, get_model
-from django.utils.functional import curry
-from django.utils.encoding import smart_str, force_unicode, smart_unicode
@@ -495 +496 @@
-
-    save_base.alters_data = True
-
-
+fields_to_null, 
-        """
-        Recursively populates seen_objs with all objects related to this
-        object.
@@ -508 +509 @@
-        if seen_objs.add(self.__class__, pk_val, self, parent, nullable):
-            return
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                else:
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-                else:
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-parent_obj._collect_sub_objects(seen_objs
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    parent_obj._collect_sub_objects(seen_objs, fields_to_null
-
-    def delete(self):
-        assert self._get_pk_val() is not None, "%s object can't be deleted because its %s attribute is set to None." % (self._meta.object_name, self._meta.pk.attname)
-
-        # Find all the objects than need to be deleted.
-        seen_objs = CollectedObjects()
-
+
+
-
-        # Actually delete the objects.
-
+, fields_to_null
-
-    delete.alters_data = True
-

db/models/fields/related.py

@@ -10 +10 @@
-from django.utils.functional import curry
-from django.core import exceptions
-from django import forms
+from django.conf import settings
-
-try:
-    set
@@ -20 +21 @@
-
-pending_lookups = {}
-
+class _OnDeleteOrUpdateAction(object):
+    pass
+class RESTRICT(_OnDeleteOrUpdateAction):
+    sql = 'RESTRICT'
+class CASCADE(_OnDeleteOrUpdateAction):
+    sql = 'CASCADE'
+class SET_NULL(_OnDeleteOrUpdateAction):
+    sql = 'SET NULL'
+ALLOWED_ON_DELETE_ACTION_TYPES = set([None, CASCADE, RESTRICT, SET_NULL])
+ALLOWED_ON_UPDATE_ACTION_TYPES = ALLOWED_ON_DELETE_ACTION_TYPES.copy()
+
-def add_lazy_relation(cls, field, relation, operation):
-    """
-    Adds a lookup on ``cls`` when a related field is defined using a string,
@@ -604 +616 @@
-
-class ManyToOneRel(object):
-    def __init__(self, to, field_name, related_name=None,
-
+
+
-        try:
-            to._meta
-        except AttributeError: # to._meta doesn't exist, so it must be RECURSIVE_RELATIONSHIP_CONSTANT
@@ -617 +630 @@
-        self.lookup_overrides = lookup_overrides or {}
-        self.multiple = True
-        self.parent_link = parent_link
+        self.on_delete = on_delete
+        self.on_update = on_update
-
-    def get_related_field(self):
-        """
@@ -631 +646 @@
-
-class OneToOneRel(ManyToOneRel):
-    def __init__(self, to, field_name, related_name=None,
-
+
+
-        super(OneToOneRel, self).__init__(to, field_name,
-                related_name=related_name, limit_choices_to=limit_choices_to,
-
+
+
-        self.multiple = False
-
-class ManyToManyRel(object):
@@ -673 +690 @@
-            related_name=kwargs.pop('related_name', None),
-            limit_choices_to=kwargs.pop('limit_choices_to', None),
-            lookup_overrides=kwargs.pop('lookup_overrides', None),
-
+
+
+
-        Field.__init__(self, **kwargs)
-
-        self.db_index = True
@@ -718 +737 @@
-            target = self.rel.to._meta.db_table
-        cls._meta.duplicate_targets[self.column] = (target, "o2m")
-
+        on_delete, on_update = self.rel.on_delete, self.rel.on_update
+        if on_delete not in ALLOWED_ON_DELETE_ACTION_TYPES:
+            raise ValueError("Invalid value 'on_delete=%s' specified for ForeignKey field %s.%s." % (on_delete, cls.__name__, name))
+        if on_update not in ALLOWED_ON_UPDATE_ACTION_TYPES:
+            raise ValueError("Invalid value 'on_update=%s' specified for ForeignKey field %s.%s." % (on_update, cls.__name__, name))
+        if (on_delete == SET_NULL or on_update == SET_NULL) and not self.null:
+            if on_delete == SET_NULL and on_update == SET_NULL:
+                specification = "'on_delete=SET_NULL' and 'on_update=SET_NULL'"
+            elif on_delete == SET_NULL:
+                specification = "'on_delete=SET_NULL'"
+            else:
+                specification = "'on_update=SET_NULL'"
+            raise ValueError("%s specified for ForeignKey field '%s.%s', but the field is not nullable." % (specification, cls.__name__, name))
+        if on_delete is None and getattr(settings, 'ON_DELETE_NONE_HANDLING', CASCADE) == SET_NULL and not self.null:
+            raise ValueError("on_delete=SET_NULL is being used by default (based on the ON_DELETE_NONE_HANDLING setting) for ForeignKey field '%s.%s', but the field is not nullable." % (specification, cls.__name__, name))
+
-    def contribute_to_related_class(self, cls, related):
-        setattr(cls, related.get_accessor_name(), ForeignRelatedObjectsDescriptor(related))
-

db/models/__init__.py

@@ -11 +11 @@
-from django.db.models.fields.subclassing import SubfieldBase
-from django.db.models.fields.files import FileField, ImageField
-from django.db.models.fields.related import ForeignKey, OneToOneField, ManyToManyField, ManyToOneRel, ManyToManyRel, OneToOneRel
+from django.db.models.fields.related import CASCADE, RESTRICT, SET_NULL
-from django.db.models import signals
-
-# Admin stages.

db/models/query.py

@@ -359 +359 @@
-            # Collect all the objects to be deleted in this chunk, and all the
-            # objects that are related to the objects that are to be deleted.
-            seen_objs = CollectedObjects()
+            fields_to_null = CollectedFields()
-            for object in del_query[:CHUNK_SIZE]:
-
+, fields_to_null
-
-            if not seen_objs:
-                break
-
+, fields_to_null
-
-        # Clear the result cache, in case this QuerySet gets reused.
-        self._result_cache = None
@@ -952 +953 @@
-                setattr(obj, f.get_cache_name(), rel_obj)
-    return obj, index_end
-
-
+, fields_to_null
-    """
-    Iterate through a list of seen classes, and remove any instances that are
-    referred to.
@@ -998 +999 @@
-                        update_query.clear_related(field, pk_list)
-
-        # Now delete the actual data.
+        for cls, cls_dct in fields_to_null.iteritems():
+            update_query = sql.UpdateQuery(cls, connection)
+            field_dict = {}
+            for pk, (_, field_names) in cls_dct.iteritems():
+                for field_name in field_names:
+                    pk_set = field_dict.setdefault(field_name, set())
+                    pk_set.add(pk)
+            for field_name, pk_set in field_dict.iteritems():
+                update_query.clear_related(cls._meta.get_field_by_name(field_name)[0], list(pk_set))
-        for cls in ordered_classes:
-            items = obj_pairs[cls]
-            items.reverse()
@@ -1009 +1019 @@
-            # Last cleanup; set NULLs where there once was a reference to the
-            # object, NULL the primary key of the found objects, and perform
-            # post-notification.
+            for cls, cls_dct in fields_to_null.iteritems():
+                for instance, field_names in cls_dct.itervalues():
+                    for field_name in field_names:
+                        field = cls._meta.get_field_by_name(field_name)[0]
+                        setattr(instance, field.attname, None)
-            for pk_val, instance in items:
-                for field in cls._meta.fields:
-                    if field.rel and field.null and field.rel.to in seen_objs:

db/models/query_utils.py

@@ -111 +111 @@
-        """
-        return self.data.keys()
-
+class CollectedFields(object):
+    """
+    A container that stores model objects and fields that need to
+    be nulled to enforce the on_delete=SET_NULL ForeignKey constraint.
+    """
+    def __init__(self):
+        self.data = {}
+
+    def add(self, model, pk, obj, field_name):
+        """
+        Adds an item.
+        model is the class of the object being added,
+        pk is the primary key, obj is the object itself, 
+        field_name is the name of the field to be nulled.
+        """
+        d = self.data.setdefault(model, SortedDict())
+        obj, field_names = d.setdefault(pk, (obj, set()))
+        field_names.add(field_name)
+
+    def __contains__(self, key):
+        return self.data.__contains__(key)
+
+    def __getitem__(self, key):
+        return self.data[key]
+
+    def __nonzero__(self):
+        return bool(self.data)
+
+    def iteritems(self):
+        return self.data.iteritems()
+
+    def iterkeys(self):
+        return self.data.iterkeys()
+
+    def itervalues(self):
+        return self.data.itervalues()
+
-class QueryWrapper(object):
-    """
-    A type that indicates the contents are an SQL fragment and the associate

db/backends/creation.py

@@ -96 +96 @@
-        "Return the SQL snippet defining the foreign key reference for a field"
-        qn = self.connection.ops.quote_name
-        if field.rel.to in known_models:
+            on_delete_clause, on_update_clause = self.on_delete_and_update_clauses(style, field)
-            output = [style.SQL_KEYWORD('REFERENCES') + ' ' + \
-                style.SQL_TABLE(qn(field.rel.to._meta.db_table)) + ' (' + \
-                style.SQL_FIELD(qn(field.rel.to._meta.get_field(field.rel.field_name).column)) + ')' +
+                on_delete_clause + on_update_clause +
-                self.connection.ops.deferrable_sql()
-            ]
-            pending = False
@@ -121 +123 @@
-        opts = model._meta
-        if model in pending_references:
-            for rel_class, f in pending_references[model]:
+                on_delete_clause, on_update_clause = self.on_delete_and_update_clauses(style, f)
-                rel_opts = rel_class._meta
-                r_table = rel_opts.db_table
-                r_col = f.column
@@ -129 +132 @@
-                # For MySQL, r_name must be unique in the first 64 characters.
-                # So we are careful with character usage here.
-                r_name = '%s_refs_%s_%x' % (r_col, col, abs(hash((r_table, table))))
-
+%s%s
-                    (qn(r_table), qn(truncate_name(r_name, self.connection.ops.max_name_length())),
-                    qn(r_col), qn(table), qn(col),
+                    on_delete_clause, on_update_clause,
-                    self.connection.ops.deferrable_sql()))
-            del pending_references[model]
-        return final_output
-
+    def on_delete_and_update_clauses(self, style, foreign_key_field):
+        on_delete_clause = ''
+        try:
+            on_delete = getattr(foreign_key_field, 'ON_DELETE_HANDLED_BY_DB') #USED FOR UNIT TESTING ONLY (see comment in modeltests/on_delete_and_update_db/models.py)
+        except AttributeError:
+            on_delete = getattr(settings, 'ON_DELETE_HANDLED_BY_DB', False)
+        if on_delete:
+            on_delete = getattr(foreign_key_field.rel, 'on_delete', None)
+            if on_delete:
+                on_delete_clause = style.SQL_KEYWORD(' ON DELETE %s' % foreign_key_field.rel.on_delete.sql)
+            
+        on_update_clause = ''
+        try:
+            on_update = getattr(foreign_key_field, 'ON_UPDATE_HANDLED_BY_DB') #USED FOR UNIT TESTING ONLY; (see comment in modeltests/on_delete_and_update_db/models.py)
+        except AttributeError:
+            on_update = getattr(settings, 'ON_UPDATE_HANDLED_BY_DB', False)
+        if on_update:
+            on_update = getattr(foreign_key_field.rel, 'on_update', None)
+            if on_update:
+                on_update_clause = style.SQL_KEYWORD(' ON UPDATE %s' % foreign_key_field.rel.on_update.sql)
+
+        return on_delete_clause, on_update_clause
+        
-    def sql_for_many_to_many(self, model, style):
-        "Return the CREATE TABLE statments for all the many-to-many tables defined on a model"
-        output = []

contrib/admin/options.py

@@ -1006 +1006 @@
-        perms_needed = set()
-        get_deleted_objects(deleted_objects, perms_needed, request.user, obj, opts, 1, self.admin_site)
-
+        import logging; logging.debug('deleting %s' % deleted_objects)
-        if request.POST: # The user has already confirmed the deletion.
-            if perms_needed:
-                raise PermissionDenied