Ticket #6095: 6095-alpha-05.diff

django/db/models/fields/related.py

@@ -1 +1 @@
 from django.db import connection, transaction
-from django.db.models import signals, get_model
+from django.db.models import signals, get_model, get_models
 from django.db.models.fields import AutoField, Field, IntegerField, PositiveIntegerField, PositiveSmallIntegerField, get_ul_class
 from django.db.models.related import RelatedObject
 from django.utils.text import capfirst
 from django.utils.translation import ugettext_lazy, string_concat, ungettext, ugettext as _
-from django.utils.functional import curry
+from django.utils.functional import curry, memoize
 from django.utils.encoding import smart_unicode
 from django.core import validators
 from django import oldforms
@@ -23 +23 @@
 
 pending_lookups = {}
 
+memoized_fk_field_reversals = {}
+
+model_db_table_cache = {}
+
 def add_lookup(rel_cls, field):
     name = field.rel.to
     module = rel_cls.__module__
@@ -54 +58 @@
     except klass.DoesNotExist:
         raise validators.ValidationError, _("Please enter a valid %s.") % f.verbose_name
 
+def get_reverse_rel_field(from_model, to_model, related_name):
+    "Gets the related field which points from one model to another."
+    key = (from_model._meta.app_label, from_model._meta.object_name,
+            to_model._meta.app_label, to_model._meta.object_name,
+            related_name)
+    try:
+        found_field = memoized_fk_field_reversals[key]
+    except KeyError:
+        found_field = None
+        for field in from_model._meta.fields:
+            if field.__class__ in (ForeignKey, OneToOneField, ManyToManyField):
+                if field.rel.to == to_model:
+                    found_field = field
+                    break
+        memoized_fk_field_reversals[key] = found_field
+    return found_field
+
+def get_model_for_db_table(db_table):
+    "Gets a model class from a db_table string."
+    for model in get_models():
+        if model._meta.db_table == db_table:
+            return model
+    return None
+get_model_for_db_table = memoize(get_model_for_db_table, model_db_table_cache, 1)
+
 #HACK
 class RelatedField(object):
     def contribute_to_class(self, cls, name):
@@ -267 +296 @@
     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, source_attname=None,
+                target_attname=None, target_col_name=None):
             super(ManyRelatedManager, self).__init__()
             self.core_filters = core_filters
             self.model = model
@@ -276 +306 @@
             self.join_table = join_table
             self.source_col_name = source_col_name
             self.target_col_name = target_col_name
+            self.source_attname = source_attname
+            self.target_attname = target_attname
+            self.intermediary_model = get_model_for_db_table(self.join_table.replace('"',''))
             self._pk_val = self.instance._get_pk_val()
             if self._pk_val is None:
                 raise ValueError("%r instance needs to have a primary key value before a many-to-many relationship can be used." % model)
@@ -340 +373 @@
 
                 # 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)" % \
+                    if self.intermediary_model == None:
+                        cursor.execute("INSERT INTO %s (%s, %s) VALUES (%%s, %%s)" % \
                         (self.join_table, source_col_name, target_col_name),
                         [self._pk_val, obj_id])
+                    else:
+                        new_obj = self.intermediary_model()
+                        setattr(new_obj, self.source_attname, self._pk_val)
+                        setattr(new_obj, self.target_attname, obj_id)
+                        new_obj.save()
                 transaction.commit_unless_managed()
 
         def _remove_items(self, source_col_name, target_col_name, *objs):
@@ -398 +437 @@
         RelatedManager = create_many_related_manager(superclass)
 
         qn = connection.ops.quote_name
+        rel_field = self.related.field
         manager = RelatedManager(
             model=rel_model,
             core_filters={'%s__pk' % self.related.field.name: instance._get_pk_val()},
             instance=instance,
             symmetrical=False,
-            join_table=qn(self.related.field.m2m_db_table()),
-            source_col_name=qn(self.related.field.m2m_reverse_name()),
-            target_col_name=qn(self.related.field.m2m_column_name())
+            join_table=qn(rel_field.m2m_db_table()),
+            source_col_name=qn(rel_field.m2m_reverse_name()),
+            target_col_name=qn(rel_field.m2m_column_name()),
+            source_attname=rel_field.m2m_reverse_attname(),
+            target_attname=rel_field.m2m_attname()
         )
 
         return manager
@@ -446 +488 @@
             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()),
-            target_col_name=qn(self.field.m2m_reverse_name())
+            target_col_name=qn(self.field.m2m_reverse_name()),
+            source_attname=self.field.m2m_attname(),
+            target_attname=self.field.m2m_reverse_attname()
         )
 
         return manager
@@ -648 +692 @@
             filter_interface=kwargs.pop('filter_interface', None),
             limit_choices_to=kwargs.pop('limit_choices_to', None),
             raw_id_admin=kwargs.pop('raw_id_admin', False),
-            symmetrical=kwargs.pop('symmetrical', True))
+            symmetrical=kwargs.pop('symmetrical', True),
+            through=kwargs.pop('through', None))
         self.db_table = kwargs.pop('db_table', None)
+        if kwargs['rel'].through:
+            assert not self.db_table, "Cannot specify a db_table if an intermediary model is used."
         if kwargs["rel"].raw_id_admin:
             kwargs.setdefault("validator_list", []).append(self.isValidIDList)
         Field.__init__(self, **kwargs)
@@ -672 +719 @@
 
     def _get_m2m_db_table(self, opts):
         "Function that can be curried to provide the m2m table name for this relation"
-        if self.db_table:
+        if self.rel.through != None:
+            return get_model(opts.app_label, self.rel.through)._meta.db_table
+        elif self.db_table:
             return self.db_table
         else:
             return '%s_%s' % (opts.db_table, self.name)
 
+    def _get_m2m_attname(self, related):
+        try:
+            through = get_model(related.opts.app_label, self.rel.through)
+            field = get_reverse_rel_field(through, related.model, self.rel.related_name)
+            attname, column = field.get_attname_column()
+            return attname
+        except:
+            return None
+
     def _get_m2m_column_name(self, related):
         "Function that can be curried to provide the source column name for the m2m table"
         # If this is an m2m relation to self, avoid the inevitable name clash
-        if related.model == related.parent_model:
+        if self.rel.through != None:
+            through = get_model(related.opts.app_label, self.rel.through)
+            field = get_reverse_rel_field(through, related.model, self.rel.related_name)
+            attname, column = field.get_attname_column()
+            return column
+        elif related.model == related.parent_model:
             return 'from_' + related.model._meta.object_name.lower() + '_id'
         else:
             return related.model._meta.object_name.lower() + '_id'
 
+    def _get_m2m_reverse_attname(self, related):
+        try:
+            through = get_model(related.opts.app_label, self.rel.through)
+            field = get_reverse_rel_field(through, related.parent_model, self.rel.related_name)
+            attname, column = field.get_attname_column()
+            return attname
+        except:
+            return None
+
     def _get_m2m_reverse_name(self, related):
         "Function that can be curried to provide the related column name for the m2m table"
         # If this is an m2m relation to self, avoid the inevitable name clash
-        if related.model == related.parent_model:
+        if self.rel.through != None:
+            through = get_model(related.opts.app_label, self.rel.through)
+            field = get_reverse_rel_field(through, related.parent_model, self.rel.related_name)
+            attname, column = field.get_attname_column()
+            return column
+        elif related.model == related.parent_model:
             return 'to_' + related.parent_model._meta.object_name.lower() + '_id'
         else:
             return related.parent_model._meta.object_name.lower() + '_id'
@@ -745 +822 @@
         # Set up the accessors for the column names on the m2m table
         self.m2m_column_name = curry(self._get_m2m_column_name, related)
         self.m2m_reverse_name = curry(self._get_m2m_reverse_name, related)
+        self.m2m_attname = curry(self._get_m2m_attname, related)
+        self.m2m_reverse_attname = curry(self._get_m2m_reverse_attname, related)
 
     def set_attributes_from_rel(self):
         pass
@@ -809 +888 @@
 
 class ManyToManyRel(object):
     def __init__(self, to, num_in_admin=0, related_name=None,
-        filter_interface=None, limit_choices_to=None, raw_id_admin=False, symmetrical=True):
+        filter_interface=None, limit_choices_to=None, raw_id_admin=False, symmetrical=True,
+        through = None):
         self.to = to
         self.num_in_admin = num_in_admin
         self.related_name = related_name
@@ -821 +901 @@
         self.raw_id_admin = raw_id_admin
         self.symmetrical = symmetrical
         self.multiple = True
+        self.through = through
 
         assert not (self.raw_id_admin and self.filter_interface), "ManyToManyRels may not use both raw_id_admin and filter_interface"

django/core/management/validation.py

@@ -104 +104 @@
                         if r.get_accessor_name() == rel_query_name:
                             e.add(opts, "Reverse query name for field '%s' clashes with related field '%s.%s'. Add a related_name argument to the definition for '%s'." % (f.name, rel_opts.object_name, r.get_accessor_name(), f.name))
 
+        seen_intermediary_signatures = []
+
         for i, f in enumerate(opts.many_to_many):
             # Check to see if the related m2m field will clash with any
             # existing fields, m2m fields, m2m related objects or related objects
@@ -113 +115 @@
                 # so skip the next section
                 if isinstance(f.rel.to, (str, unicode)):
                     continue
+            if hasattr(f.rel, 'through') and f.rel.through != None:
+                intermediary_model = None
+                for model in models.get_models():
+                    if model._meta.module_name == f.rel.through.lower():
+                        intermediary_model = model
+                if intermediary_model == None:
+                    e.add(opts, "%s has a manually-defined m2m relationship through a model (%s) which does not exist." % (f.name, f.rel.through))
+                else:
+                    signature = (f.rel.to, cls, intermediary_model)
+                    if signature in seen_intermediary_signatures:
+                        e.add(opts, "%s has two manually defined m2m relationships through the same model (%s), which is not possible.  Please use a field on your intermediary model instead." % (cls._meta.object_name, intermediary_model._meta.object_name))
+                    else:
+                        seen_intermediary_signatures.append(signature)
+                    seen_related_fk, seen_this_fk, is_related = False, False, False
+                    for field in intermediary_model._meta.fields:
+                        if field.rel:
+                            if field.rel.to == f.rel.to:
+                                is_related = True
+                                seen_related_fk = True
+                            elif field.rel.to == cls:
+                                is_related = True
+                                seen_this_fk = True
+                        if is_related == True:
+                            is_related = False
+                            if field.default == None and field.null == False:
+                                e.add(opts, "%s is an intermediary model which has a non-nullable field (%s) with no default value" % (intermediary_model._meta.object_name, field.name))
+                    if not seen_related_fk or not seen_this_fk:
+                        e.add(opts, "%s has a manualy-defined m2m relationship through a model (%s) which does not have foreign keys to %s and %s" % (f.name, f.rel.through, f.rel.to._meta.object_name, cls._meta.object_name))
 
             rel_opts = f.rel.to._meta
             rel_name = RelatedObject(f.rel.to, cls, f).get_accessor_name()

django/core/management/sql.py

@@ -349 +349 @@
     qn = connection.ops.quote_name
     inline_references = connection.features.inline_fk_references
     for f in opts.many_to_many:
-        if not isinstance(f.rel, generic.GenericRel):
+        if not isinstance(f.rel, generic.GenericRel) and getattr(f.rel, 'through', None) == None:
             tablespace = f.db_tablespace or opts.db_tablespace
             if tablespace and connection.features.supports_tablespaces and connection.features.autoindexes_primary_keys:
                 tablespace_sql = ' ' + connection.ops.tablespace_sql(tablespace, inline=True)

tests/modeltests/invalid_models/models.py

@@ -111 +111 @@
 class MissingRelations(models.Model):
     rel1 = models.ForeignKey("Rel1")
     rel2 = models.ManyToManyField("Rel2")
+    
+class MissingManualM2MModel(models.Model):
+    name = models.CharField(max_length=5)
+    missing_m2m = models.ManyToManyField(Model, through="MissingM2MModel")
+    
+class Person(models.Model):
+    name = models.CharField(max_length=5)
 
+class Group(models.Model):
+    name = models.CharField(max_length=5)
+    primary = models.ManyToManyField(Person, through="Membership", related_name="primary")
+    secondary = models.ManyToManyField(Person, through="Membership", related_name="secondary")
+
+class GroupTwo(models.Model):
+    name = models.CharField(max_length=5)
+    primary = models.ManyToManyField(Person, through="Membership")
+    secondary = models.ManyToManyField(Group, through="MembershipMissingFK")
+
+class Membership(models.Model):
+    person = models.ForeignKey(Person)
+    group = models.ForeignKey(Group)
+    not_default_or_null = models.CharField(max_length=5)
+
+class MembershipMissingFK(models.Model):
+    person = models.ForeignKey(Person)
+
 model_errors = """invalid_models.fielderrors: "charfield": CharFields require a "max_length" attribute.
 invalid_models.fielderrors: "decimalfield": DecimalFields require a "decimal_places" attribute.
 invalid_models.fielderrors: "decimalfield": DecimalFields require a "max_digits" attribute.
@@ -197 +222 @@
 invalid_models.selfclashm2m: Reverse query name for m2m field 'm2m_4' clashes with field 'SelfClashM2M.selfclashm2m'. Add a related_name argument to the definition for 'm2m_4'.
 invalid_models.missingrelations: 'rel2' has m2m relation with model Rel2, which has not been installed
 invalid_models.missingrelations: 'rel1' has relation with model Rel1, which has not been installed
+invalid_models.group: Group has two manually defined m2m relationships through the same model (Membership), which is not possible.  Please use a field on your intermediary model instead.
+invalid_models.missingmanualm2mmodel: missing_m2m has a manually-defined m2m relationship through a model (MissingM2MModel) which does not exist.
+invalid_models.grouptwo: primary has a manualy-defined m2m relationship through a model (Membership) which does not have foreign keys to Person and GroupTwo
+invalid_models.grouptwo: secondary has a manualy-defined m2m relationship through a model (MembershipMissingFK) which does not have foreign keys to Group and GroupTwo
 """

tests/modeltests/m2m_manual/models.py

@@ +1 @@
+from django.db import models
+from datetime import datetime
+
+# M2M described on one of the models
+class Person(models.Model):
+    name = models.CharField(max_length=128)
+
+    def __unicode__(self):
+        return self.name
+
+class Group(models.Model):
+    name = models.CharField(max_length=128)
+    members = models.ManyToManyField(Person, through='Membership')
+    custom_members = models.ManyToManyField(Person, through='CustomMembership', related_name="custom")
+    
+    def __unicode__(self):
+        return self.name
+
+class Membership(models.Model):
+    person = models.ForeignKey(Person)
+    group = models.ForeignKey(Group)
+    date_joined = models.DateTimeField(default=datetime.now)
+    invite_reason = models.CharField(max_length=64, null=True, blank=True)
+    
+    def __unicode__(self):
+        return "%s is a member of %s" % (self.person.name, self.group.name)
+
+class CustomMembership(models.Model):
+    person = models.ForeignKey(Person, db_column="custom_person_column", related_name="custom_person_related_name")
+    group = models.ForeignKey(Group)
+    weird_fk = models.ForeignKey(Membership, null=True)
+    date_joined = models.DateTimeField(default=datetime.now)
+    
+    def __unicode__(self):
+        return "%s is a member of %s" % (self.person.name, self.group.name)
+
+__test__ = {'API_TESTS':"""
+>>> from datetime import datetime
+
+>>> bob = Person(name = 'Bob')
+>>> bob.save()
+>>> jim = Person(name = 'Jim')
+>>> jim.save()
+>>> jane = Person(name = 'Jane')
+>>> jane.save()
+>>> rock = Group(name = 'Rock')
+>>> rock.save()
+>>> roll = Group(name = 'Roll')
+>>> roll.save()
+
+>>> rock.members.add(jim, jane)
+>>> rock.members.all()
+[<Person: Jim>, <Person: Jane>]
+
+>>> roll.members.add(bob, jim)
+>>> roll.members.all()
+[<Person: Bob>, <Person: Jim>]
+
+>>> jane.group_set.all()
+[<Group: Rock>]
+
+>>> jane.group_set.add(roll)
+>>> jane.group_set.all()
+[<Group: Rock>, <Group: Roll>]
+
+>>> jim.group_set.all()
+[<Group: Rock>, <Group: Roll>]
+
+# Check to make sure that the associated Membership object is created.
+>>> m = Membership.objects.get(person = jane, group = rock)
+>>> m
+<Membership: Jane is a member of Rock>
+
+# Setting some date_joined dates
+>>> m.invite_reason = "She was just so awesome."
+>>> m.date_joined = datetime(2004, 1, 1)
+>>> m.save()
+
+>>> m = Membership.objects.get(person = jane, group = roll)
+>>> m.date_joined = datetime(2004, 1, 1)
+>>> m.save()
+
+>>> m = Membership.objects.get(person = bob, group = roll)
+>>> m.date_joined = datetime(2004, 1, 1)
+>>> m.save()
+
+>>> Membership.objects.filter(person = jim)
+[<Membership: Jim is a member of Rock>, <Membership: Jim is a member of Roll>]
+
+>>> rock.custom_members.add(bob)
+>>> rock.custom_members.all()
+[<Person: Bob>]
+
+>>> jim.custom.add(rock)
+>>> rock.custom_members.all()
+[<Person: Bob>, <Person: Jim>]
+
+>>> jim.custom.all()
+[<Group: Rock>]
+
+>>> jim.custom_person_related_name.all()
+[<CustomMembership: Jim is a member of Rock>]
+
+###QUERY TESTS###
+# Queries involving the related model (Person, in the case of Group) use its attname
+>>> Group.objects.filter(members__name='Bob')
+[<Group: Roll>]
+
+# Queries involving the relationship model (Membership, in the case of Group) use its model name
+>>> Group.objects.filter(membership__invite_reason = "She was just so awesome.")
+[<Group: Rock>]
+
+# Queries involving the reverse related model (Group, in the case of Person) use its model name
+>>> Person.objects.filter(group__name="Rock")
+[<Person: Jim>, <Person: Jane>]
+
+# If the m2m field has specified a related_name, using that will work.
+>>> Person.objects.filter(custom__name="Rock")
+[<Person: Bob>, <Person: Jim>]
+
+# Queries involving the relationship model (Membership, in the case of Group) use its model name
+>>> Person.objects.filter(membership__invite_reason = "She was just so awesome.")
+[<Person: Jane>]
+
+# Let's see all of the groups that Jane joined after 1 Jan 2005:
+>>> Group.objects.filter(membership__date_joined__gt = datetime(2005, 1, 1))
+[<Group: Rock>, <Group: Roll>]
+
+# Now let's see all of the people that have joined Rock since 1 Jan 2005:
+>>> Person.objects.filter(membership__date_joined__gt = datetime(2005, 1, 1))
+[<Person: Jim>, <Person: Jim>]
+
+# Oops, that returned non-distinct results, let's fix that:
+>>> Person.objects.filter(membership__date_joined__gt = datetime(2005, 1, 1)).distinct()
+[<Person: Jim>]
+"""}
+ No newline at end of file