标签: many-to-many

我的代码中有这个模型:

class Conversation(models.Model):
    participants = models.ManyToManyField(User, related_name="message_participants")

我需要通过"参与者"多对多字段过滤这个"对话"模型对象.意思是:我有3个用户对象,所以我想检索唯一的"对话"对象,其中有3个用户在其"参与者"字段中.

我试过这样做:

def get_exist_conv_or_none(sender,recipients):
    conv = Conversation.objects.filter(participants=sender)
    for rec in recipients:
        conv = conv.filter(participants=rec)

其中sender是User对象,"recipients"是User对象列表.它不会引发错误,但它给了我错误的对话对象.谢谢.

编辑:最近的一次尝试引导我:

def get_exist_conv_or_none(sender,recipients):
    participants=recipients
    participants.append(sender)
    conv = Conversation.objects.filter(participants__in=participants)
    return conv

这基本上有同样的问题.它产生的对象在列表中有一个或多个"参与者".但我正在寻找的是多对多对象的精确匹配.意思是,一个具有确切"用户"的对象是多对多关系.

编辑2:我的最后一次尝试.仍然,不会工作.

def get_exist_conv_or_none(sender,recipients):
    recipients.append(sender)
    recipients = list(set(recipients))
    conv = Conversation.objects.annotate(count=Count('participants')).filter(participants=recipients[0])
    for participant in recipients[1:]:
        conv.filter(participants=participant)
    conv.filter(count=len(recipients))
    return conv

我使用Loggable行为扩展来记录我的实体中的更改.我想记录manyToMany关系中的更改.我想向用户显示这种更改日志:

+--------------------------------------------------+
| Article "My Article" change log:                 |
+-------+------------+-----------------------------+
| Who   | When       | What                        |
+-------+------------+-----------------------------+
| Admin | 2015-07-01 | Removed tags "tag1", "tag2" |
| Admin | 2015-07-01 | Added tags "tag3"           |
+-------+------------+-----------------------------+

事件问题

我认为,当manyToMany关系发生变化时,Doctrine不会触发事件,因此Loggable(监听学说事件)不会保存日志条目.我可以通过创建自己的manyToMany表来解决它,但这是第二个问题:

拥有ManyToMany问题

当我在没有@JoinTable注释的情况下创建表示manyToMany关系的实体时,我不知道如何编写新实体以像旧的JoinTable一样.我不希望BC休息.你能给我一个线索,Doctrine如何处理这个问题？

您有什么建议,如何记录manyToMany关系中的变化？

首先 - 为模糊标题道歉,我找不到更好的标题.

我有以下结构的表(简化):

EmpID DeptID

1     1
1     2
2     1
3     2
4     5
5     2

此表表示多对多关系.

我有兴趣找到与特定DeptID组相关的所有EmpID,例如我想要所有与DeptID 1,2和3相关的EmpID.请注意它是AND关系而不是OR关系.对于我的情况,EmpID可能与除1,2和3之外的其他DeptID相关,因为它是有效的答案.

我感兴趣的DeptID数量有所变化(即我可能想要与DeptID 3和5相关的EmpID,或者我可能想要与DepID 2,3,4,5,6,7相关的EmpID).

当我尝试解决这个问题时,我发现自己要么每个DepID创建一个JOIN,要么每个DeptID创建一个子查询.这意味着我必须根据我正在测试的DeptID数量生成一个新查询.我显然更喜欢使用参数或参数集进行静态查询.

我正在研究SQL Server和MySQL(并行开发两个版本的代码).

有任何想法吗？

我有以下型号:

class Message(models.Model):
    date = models.DateTimeField()
    user = models.ForeignKey(User)    
    thread = models.ForeignKey('self', blank=True, null=True)
    ...

class Forum(models.Model):
    name = models.CharField(max_length=24)
    messages = models.ManyToManyField(Message, through="Message_forum", blank=True, null=True)
    ...

class Message_forum(models.Model):
    message = models.ForeignKey(Message)
    forum = models.ForeignKey(Forum)
    status = models.IntegerField()
    position = models.IntegerField(blank=True, null=True)
    tags = models.ManyToManyField(Tag, blank=True, null=True)

在管理站点中,当我去添加/更改论坛时,我没有看到您期望的消息列表框.但是,如果我删除ManyToManyField声明中的'through'参数,它会显示出来.那是怎么回事？我已将所有三个模型(加上Tag)注册到admin.py中的管理站点.

TIA

我的django项目中有以下模型:

class Video(models.Model):
    media = models.ForeignKey(Media)

class Media(models.Model):
    title = models.CharField(max_length=255)
    formats = models.ManyToManyField(Format,through='MediaFormat',related_name='media',blank=True)

class Format(models.Model):
    title = models.CharField(max_length=50)

class MediaFormat(models.Model):
    status = models.IntegerField()
    format = models.ForeignKey(Format)
    media = models.ForeignKey(Media)

现在,我想过滤所有具有特定格式的视频,并且该格式的状态代码为10(可以使用).我怎样才能做到这一点？(假设f是格式):

f = Format.objects.get(pk=3)

我很想用:

Video.objects.filter(media__formats=f, media__mediaformat__status=10)

但是,这将返回所有符合这两个假设的视频:

• a)包含该特定格式,以及
• b)包含状态为10的任何格式

我该如何过滤只有状态代码为10的那种特定格式的人？

谢谢!

我有以下表Essence,EssenseSet和Essense2EssenceSet

Essense2EssenceSet 是创建M:M关系的链接表.

虽然在EF代码中,我一直无法使M:M关系正常工作.

这是我的代码:

[Table("Essence", Schema = "Com")]
    public class Essence
    {
        public int EssenceID { get; set; }
        public string Name { get; set; }
        public int EssenceTypeID { get; set; }
        public string DescLong { get; set; }
        public string DescShort { get; set; }
        public virtual ICollection<EssenceSet> EssenceSets { get; set; }
        public virtual EssenceType EssenceType { get; set; }
    }

    [Table("EssenceSet", Schema = "Com")]
    public class EssenceSet
    {
        public int …

我和人事部门之间有多对多的关系,因为一个人可以在很多部门工作.

People          Departments
------          -----------
pID  pName      deptID   deptName
1    James      1        Engineering
2    Mary       2        Research
3    Paul       3        Marketing
                4        Communications

People_Departments
------------------
pID   deptID
1     1
1     2
2     2
2     4
3     1
3     2
3     3

我想要的是这个:

pName  deptName
James  Engineering, Research
Mary   Research, Communication
Paul   Engineering, Research, Marketing

如果我使用下面的SQL在表上执行简单的LEFT JOIN,我将获得与一个人相关的几行:

SELECT people.pName,
       departments.deptName
FROM people
LEFT JOIN people_departments ON people.pID=people_departments.pID
LEFT JOIN departments ON people_departments.deptID=departments.deptID

我尝试了各种组合,GROUP_CONCAT但没有运气.

有什么想法可以分享？

我想删除具有许多用户组的用户,但这些用户组不属于该用户:其他用户也可以使用此用户组.即使没有用户引用用户组,也可以存在用户组.

我想映射多对多关系,这样如果用户被删除,关系会自动删除但不是用户组？

我试过,Cascade.All因为我认为多对多的级联会影响关系但不会影响另一方.我以为只会Cascade.AllDeleteOrphan删除其他人.显然我错了.

似乎我不理解级联规则.有人可以向我提供明确的解释,也许也可以达到我的目标吗？

谢谢

我在SQLAlchemy中遇到了一个问题,并在编写时找到了解决方案.无论如何,我发布它,以防它有助于某人:)

假设我有很多关系似乎有效(至少我可以取儿)三个表:帖子,标签和post_tags.

import sqlalchemy as alc

class Tag(Base):
    __tablename__ = 'tags'

    id = alc.Column(alc.Integer, primary_key=True)
    name = alc.Column(alc.String)
    accepted = alc.Column(alc.Integer)

    posts = relationship('Post', secondary=post_tags)



class Post(Base):

    __tablename__ = 'posts'

    id = alc.Column(alc.Integer, primary_key=True)
    text = alc.Column(alc.String)
    date_out = alc.Column(alc.Date)

    tags = relationship('Mistake_Code', secondary=post_tags)

# relational table
post_tags = alc.Table('check_point_mistakes',
                       Base.metadata,
                       alc.Column('post_id', alc.Integer,ForeignKey('posts.id')),
                       alc.Column('tag_id', alc.Integer, alc.ForeignKey('tags.id')))

现在我的问题是我想先在Post中使用date_out进行过滤.我可以这样得到它:

# assume start_date and end_date

query = (
            session.query(Post)
                   .filter(Post.date_out.between(start_date, end_date))
 )

但是如何同时按标签过滤？

我正在尝试优化我的@Entity课程.让我们来看一个User <-> Group关系的常见情况.我还想存储建立关系的日期.表格布局:

 USER      GROUP_USER      GROUP
------    ------------    -------
 id        user_id         id
 name      group_id        name
           createdAt

有以下3个类:

1. User 同 @OneToMany List<GroupUser>
2. GroupUser用@ManyToOne User和@ManyToOne Group
3. Group 同 @OneToMany List<GroupUser>

它有效,但它很常见的常见用例.例如:给我所有组User user:

List<Group> groups;
for(GroupUser gu : user.getGroupUsers) {
    groups.add(gu.getGroup());
}

然后我想到了使用a的Map想法.所以我创建了以下3个类:

@Entity
class User {
   @Column(name="id")
   UUID id;

   @Column(name="name")
   String name;

   @ElementCollection
   @CollectionTable(name="Group_User")
   Map<Group, GroupUserRelationData> groups;
}

@Entity
class Group {
   @Column(name="id")
   UUID id;

   @Column(name="name")
   String name;

   @ElementCollection …