Django ManyToMany 与 'self' 的关系没有向后关系

Question

这里有几个关于向后关系的问题，但我要么太笨而无法理解它们，要么认为它们不适合我的情况。

我有模型

class MyModel(models.Model)
    stuff = models.ManyToManyField('self', related_name = 'combined+')

我创建了表单，将存储的信息组合起来。它在数据库中存储对象关系，如下所示:

表:

id:from_stuff_id:to_stuff_id
1:original_object_id:first_related_object
2:original_object_id:second_related_object
3:first_related_object:original_object_id
4:second_related_object:original_object_id

因此，当我显示对象first_lated_object并检查与

的关系时

myobject.stuff.all()

然后我得到“original_object”。但我不需要它。我希望它不会显示出这样的向后关系。

编辑1

所以我很难解释自己。

也许这段代码能更好地说明我想要的。

myobjectone = MyModel.objects.get(pk = 1)
myobjecttwo = MyModel.objects.get(pk = 2)
myobjectthree = MyModel.objects.get(pk = 3)
myobjectone.stuff.add(myobjecttwo)
myobjectone.stuff.add(myobjectthree)
myobjectone.stuff.all()
[myobjecttwo, myobjectthree] <-- this i want
myobjecttwo.stuff.all()
[myobjectone]<-- this i do not want
myobjectthree.stuff.all()
[myobjectone]<-- this i do not want

现在唯一的问题是 - 如果我不想要它们产生的结果，我是否应该使用 stuff.all() 并且应该编写我自己的管理器/方法来获取排除向后关系的对象列表。

/编辑1

编辑2回应亨利·弗洛伦斯:

好吧 - 我确实用空基测试了它，看起来对称 = False 确实存在数据库级别差异。我认为。

我使用对称 = False 创建了空表，然后创建添加关系并没有产生向后关系。如果我创建了没有对称的空表= False。然后他们就是了。创建表后，设置对称 = False 没有任何区别。所以我猜差异在于数据库级别。

/编辑2那么我应该在这里做什么？

写我自己的经理还是什么？

艾伦

Answer 1

我对这个问题的理解是，多对多关系应该是一种方式，如果以下情况为真:

             --------------           ----------------
             | mymodelone |---------->|  mymodeltwo  |
             --------------     |     ----------------
                                |
                                |     ----------------
                                ----->| mymodelthree |
                                      ----------------

那么另一个方向上不应该存在隐式关系:

             --------------           ----------------
             | mymodelone |<-----/----|  mymodeltwo  |
             --------------           ----------------

             --------------           ----------------
             | mymodelone |<-----/----| mymodelthree |
             --------------           ----------------

ManyToMany 字段具有 symmetry 属性，默认情况下为 True，请参阅:here .

要创建一个新应用来演示非对称 ManyToMany 字段:

创建一个新应用:

$ python ./manage.py startapp stuff

在settings.py中添加东西应用程序:

...
INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'stuff'
)
....

编辑`stuff/models.py:

from django.db import models

class MyModel(models.Model):
    stuff = models.ManyToManyField('self', related_name = 'combined+', symmetrical=False, blank = True, null = True, verbose_name = "description")

    def __unicode__(self):
        return "MyModel%i" % self.id

同步数据库:

$ python ./manage.py syncdb
Creating tables ...
Creating table stuff_mymodel_stuff
Creating table stuff_mymodel
Installing custom SQL ...
Installing indexes ...
Installed 0 object(s) from 0 fixture(s)

然后在django shell中测试:

$ python ./manage.py shell
>>> from stuff.models import MyModel
>>> MyModel().save()
>>> MyModel().save()
>>> MyModel().save()
>>> MyModel.objects.all()
[<MyModel: MyModel1>, <MyModel: MyModel2>, <MyModel: MyModel3>]
>>> m1 = MyModel.objects.get(pk=1)
>>> m2 = MyModel.objects.get(pk=2)
>>> m3 = MyModel.objects.get(pk=3)
>>> m1.stuff.all()
[]
>>> m1.stuff.add(m2)
>>> m1.stuff.add(m3)
>>> m1.stuff.all()
[<MyModel: MyModel2>, <MyModel: MyModel3>]
>>> m2.stuff.all()
[]
>>> m3.stuff.all()
[]
>>> 

编辑 - 现有模型上的多对多关系

ManyToManyField 的对称性是在将模型写入数据库时​​创建的，而不是在读取模型时创建的。如果我们将模型更改为:

from django.db import models

class MyModel(models.Model):
    stuff = models.ManyToManyField('self', related_name = 'combined+')

def __unicode__(self):
    return "MyModel%i" % self.id

创建新的MyModel实例:

>>> MyModel().save()
>>> MyModel().save()
>>> MyModel.objects.all()
[<MyModel: MyModel1>, <MyModel: MyModel2>, <MyModel: MyModel3>, <MyModel: MyModel4>, <MyModel: MyModel5>]
>>> m4 = MyModel.objects.get(pk=4)
>>> m5 = MyModel.objects.get(pk=5)
>>> m4.stuff.add(m5)
>>> m4.stuff.all()
[<MyModel: MyModel5>]
>>> m5.stuff.all()
[<MyModel: MyModel4>]

正如预期的那样，ManyToManyField 正在创建对称关系。如果我们随后将 ManyToManyField 设置为 symmetry = False:

>>> from stuff.models import MyModel
>>> MyModel().save()
>>> MyModel().save()
>>> MyModel.objects.all()
[<MyModel: MyModel1>, <MyModel: MyModel2>, <MyModel: MyModel3>, <MyModel: MyModel4>, <MyModel: MyModel5>, <MyModel: MyModel6>, <MyModel: MyModel7>]
>>> m6 = MyModel.objects.get(pk=6)
>>> m7 = MyModel.objects.get(pk=7)
>>> m6.stuff.all()
[]
>>> m7.stuff.all()
[]
>>> m6.stuff.add(m7)
>>> m6.stuff.all()
[<MyModel: MyModel7>]
>>> m7.stuff.all()
[]
>>> m5 = MyModel.objects.get(pk=5)
>>> m4 = MyModel.objects.get(pk=4)
>>> m4.stuff.all()
[<MyModel: MyModel5>]
>>> m5.stuff.all()
[<MyModel: MyModel4>]

可以看出，m6 和 m7 之间的新 ManyToMany 关系并不对称，而 m4 之间现有的关系则不对称。 和 m5 仍然是对称的，正如创建这些对象时所声明的模型一样。

编辑 - 使用对称外键的附加数据库约束

对于这个答案的长度向读者表示歉意，我们似乎正在深入探讨这个问题。

在 SQL 中，多对多关系是通过创建一个表来建模的，该表保存该关系特有的所有信息 - 通常只是两个表的主键值。

因此，对于我们的 MyModel，django 创建了两个表:

             -----------------           -----------------------
             | stuff_mymodel |---------->| stuff_mymodel_stuff |
             -----------------           -----------------------
                      ^                              |
                      |                              |
                      --------------------------------

图中显示的链接由架构中的主键或 id 值表示:

mysql> describe stuff_mymodel;
+-------+---------+------+-----+---------+----------------+
| Field | Type    | Null | Key | Default | Extra          |
+-------+---------+------+-----+---------+----------------+
| id    | int(11) | NO   | PRI | NULL    | auto_increment |
+-------+---------+------+-----+---------+----------------+
1 row in set (0.00 sec)

mysql> describe stuff_mymodel_stuff;
+-----------------+---------+------+-----+---------+----------------+
| Field           | Type    | Null | Key | Default | Extra          |
+-----------------+---------+------+-----+---------+----------------+
| id              | int(11) | NO   | PRI | NULL    | auto_increment |
| from_mymodel_id | int(11) | NO   | MUL | NULL    |                |
| to_mymodel_id   | int(11) | NO   | MUL | NULL    |                |
+-----------------+---------+------+-----+---------+----------------+
3 rows in set (0.00 sec)

并显示为 Django manage.py 脚本的输出:

$ python ./manage.py sql stuff
    BEGIN;
CREATE TABLE `stuff_mymodel_stuff` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
    `from_mymodel_id` integer NOT NULL,
    `to_mymodel_id` integer NOT NULL,
    UNIQUE (`from_mymodel_id`, `to_mymodel_id`)
)
;
CREATE TABLE `stuff_mymodel` (
    `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY
)
;
ALTER TABLE `stuff_mymodel_stuff` ADD CONSTRAINT `from_mymodel_id_refs_id_7fa00238` FOREIGN KEY (`from_mymodel_id`) REFERENCES `stuff_mymodel` (`id`);
ALTER TABLE `stuff_mymodel_stuff` ADD CONSTRAINT `to_mymodel_id_refs_id_7fa00238` FOREIGN KEY (`to_mymodel_id`) REFERENCES `stuff_mymodel` (`id`);
COMMIT;

无论 django ManyToManyField 是否对称，此 sql 都是相同的。唯一的区别是在 stuff_mymodel_stuff 表中创建的行数:

mysql> select * from stuff_mymodel_stuff;
+----+-----------------+---------------+
| id | from_mymodel_id | to_mymodel_id |
+----+-----------------+---------------+
|  1 |               1 |             2 |
|  2 |               1 |             3 |
|  3 |               4 |             5 |
|  4 |               5 |             4 |
|  5 |               6 |             7 |
+----+-----------------+---------------+
5 rows in set (0.00 sec)

链接m4 -> m5 是对称的，而其他链接则不是。深入研究 Django 源代码，我们可以找到负责在 sql 中创建“镜像”条目的代码，如果 symmetry 为 True:

    # If the ManyToMany relation has an intermediary model,
    # the add and remove methods do not exist.
    if rel.through._meta.auto_created:
        def add(self, *objs):
            self._add_items(self.source_field_name, self.target_field_name, *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_field_name, self.source_field_name, *objs)
        add.alters_data = True

目前这是 github 上的第 605 行:https://github.com/django/django/blob/master/django/db/models/fields/related.py

希望这能解答您的所有疑问。