Index: django/db/models/fields/related.py =================================================================== --- django/db/models/fields/related.py (revision 6903) +++ django/db/models/fields/related.py (working copy) @@ -1,10 +1,10 @@ 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,6 +23,10 @@ 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,6 +58,31 @@ 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,7 +296,8 @@ 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,6 +306,9 @@ 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,9 +373,15 @@ # 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,14 +437,17 @@ 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,7 +488,9 @@ 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,8 +692,11 @@ 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,23 +719,53 @@ 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,6 +822,8 @@ # 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,7 +888,8 @@ 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,5 +901,6 @@ 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" Index: django/core/management/validation.py =================================================================== --- django/core/management/validation.py (revision 6903) +++ django/core/management/validation.py (working copy) @@ -104,6 +104,8 @@ 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,6 +115,34 @@ # 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() Index: django/core/management/sql.py =================================================================== --- django/core/management/sql.py (revision 6903) +++ django/core/management/sql.py (working copy) @@ -349,7 +349,7 @@ 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) Index: tests/modeltests/invalid_models/models.py =================================================================== --- tests/modeltests/invalid_models/models.py (revision 6903) +++ tests/modeltests/invalid_models/models.py (working copy) @@ -111,7 +111,32 @@ 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,4 +222,8 @@ 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 """ Index: tests/modeltests/m2m_manual/__init__.py =================================================================== Index: tests/modeltests/m2m_manual/models.py =================================================================== --- tests/modeltests/m2m_manual/models.py (revision 0) +++ tests/modeltests/m2m_manual/models.py (revision 0) @@ -0,0 +1,136 @@ +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() +[, ] + +>>> roll.members.add(bob, jim) +>>> roll.members.all() +[, ] + +>>> jane.group_set.all() +[] + +>>> jane.group_set.add(roll) +>>> jane.group_set.all() +[, ] + +>>> jim.group_set.all() +[, ] + +# Check to make sure that the associated Membership object is created. +>>> m = Membership.objects.get(person = jane, group = rock) +>>> m + + +# 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) +[, ] + +>>> rock.custom_members.add(bob) +>>> rock.custom_members.all() +[] + +>>> jim.custom.add(rock) +>>> rock.custom_members.all() +[, ] + +>>> jim.custom.all() +[] + +>>> jim.custom_person_related_name.all() +[] + +###QUERY TESTS### +# Queries involving the related model (Person, in the case of Group) use its attname +>>> Group.objects.filter(members__name='Bob') +[] + +# 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.") +[] + +# Queries involving the reverse related model (Group, in the case of Person) use its model name +>>> Person.objects.filter(group__name="Rock") +[, ] + +# If the m2m field has specified a related_name, using that will work. +>>> Person.objects.filter(custom__name="Rock") +[, ] + +# 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.") +[] + +# 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)) +[, ] + +# 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)) +[, ] + +# Oops, that returned non-distinct results, let's fix that: +>>> Person.objects.filter(membership__date_joined__gt = datetime(2005, 1, 1)).distinct() +[] +"""} \ No newline at end of file