标签: many-to-many

我正在使用JPA 2.0和hibernate.我有一个User类和一个Group类,如下所示:

public class User implements Serializable {
    @Id
    @Column(name="USER_ID")
    private String userId;

    @ManyToMany
    @JoinTable(name = "USER_GROUP",
               joinColumns = {
                   @JoinColumn(name = "GROUP_ID")
               },
               inverseJoinColumns = {
                   @JoinColumn(name = "USER_ID")
               }
    )
    private Set<Group> groupList;

    //get set methods
}

public class Group
{
    @Id
    @Column(name="GROUP_ID")
    private String groupId;

    @ManyToMany(mappedBy="groupList")
    private Set<User> memberList;
    //get set methods
}

然后,我创建一个用户和组,然后将用户分配给该组.

我想要的是当我删除该组时,该组将被删除(当然),该组所拥有的所有用户组关系将自动从USER_GROUP连接表中删除,但用户本身不会从USER表.

使用上面的代码,当我删除一个组时,只删除GROUP表中的行,并且用户仍然会在USER_GROUP连接表中有一个已删除组的条目.

如果我将Cascade放在User类中,如下所示:

@ManyToMany(cascade=CascadeType.ALL)
@JoinTable(name = "USER_GROUP",
joinColumns =
{
    @JoinColumn(name = "GROUP_ID")
},
inverseJoinColumns =
{
    @JoinColumn(name = "USER_ID")
})
private Set<Group> …

在这种情况下,我有2个实体,如Contract,Media.

public class Media : Entity
{
    public string Name {get; set;}
    public bool Enabled
    *//other properties can be ignored..*
}

public class Contract : Entity
{
    public string Code {get; set;}
    *//other properties can be ignored..*
}

合同有很多媒体,似乎它们是多对多的.

但!!首先,在ef代码中,我需要在ContractMedia表中增加3个字段(如果自动生成).例如StartDate,EndDate和Price.这些无法在媒体实体中添加.

如何在这种情况下映射？

我正在尝试创建一个消息系统,其中消息的发件人和收件人可以是通用实体.这对于发件人来说似乎很好,其中只有引用对象(GenericForeignKey),但我无法弄清楚如何为收件人解决这个问题(GenericManyToManyKey ??)

下面是一个简化的例子.PersonClient和CompanyClient从Client继承属性,但具有自己的特定详细信息.最后一行是关键点.如何允许邮件收件人成为一组CompanyClients和PersonClients

  class Client(models.Model):
      city = models.CharField(max_length=16)

      class Meta:
          abstract = True

  class PersonClient(Client):
      first_name = models.CharField(max_length=16)
      last_name = models.CharField(max_length=16)
      gender = models.CharField(max_length=1)

  class CompanyClient(Client):
      name = models.CharField(max_length=32)
      tax_no = PositiveIntegerField()

  class Message(models.Model):
      msg_body = models.CharField(max_length=1024)
      sender = models.ForeignKey(ContentType)
      recipients = models.ManyToManyField(ContentType)

从Django文档......

当您只处理简单的多对多关系时,例如混合和匹配比萨饼和浇头,您只需要一个标准的ManyToManyField即可.但是,有时您可能需要将数据与两个模型之间的关系相关联.

例如,考虑应用程序跟踪音乐家所属的音乐组的情况.一个人与他们所属的组之间存在多对多关系,因此您可以使用ManyToManyField来表示此关系.但是,您可能希望收集的成员资格有很多详细信息,例如此人加入该组的日期.

对于这些情况,Django允许您指定将用于管理多对多关系的模型.然后,您可以在中间模型上添加额外的字段.中间模型与ManyToManyField相关联,使用through参数指向将充当中介的模型.对于我们的音乐家示例,代码看起来像这样:

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')

    def __unicode__(self):
        return self.name

class Membership(models.Model):
    person = models.ForeignKey(Person)
    group = models.ForeignKey(Group)
    date_joined = models.DateField()
    invite_reason = models.CharField(max_length=64)

现在您已经设置了ManyToManyField以使用您的中间模型(在这种情况下为Membership),您已准备好开始创建一些多对多关系.您可以通过创建中间模型的实例来完成此操作:

ringo = Person.objects.create(name="Ringo Starr")
paul = Person.objects.create(name="Paul McCartney")
beatles = Group.objects.create(name="The Beatles")

m1 = Membership(person=ringo, group=beatles,
...     date_joined=date(1962, 8, 16),
...     invite_reason= "Needed a new drummer.")

m1.save()

beatles.members.all()
[<Person: Ringo Starr>]

ringo.group_set.all()
[<Group: The Beatles>]

m2 = Membership.objects.create(person=paul, group=beatles, …

我在Django模型中解决关系时遇到了一些困难.

有人可以解释OneToOne,ManyToMany和ForeignKey之间的区别吗？

我似乎无法完成这项工作

class Member
{
    public virtual IList<Member> Friends { get; set; }
    [Key]
    public int MemberId { get; set; }
    public string Name{ get; set; }
}

我尝试添加Mappings但是徒劳无功.有没有办法用CTP5这样做？

我有3个表:User,Community,community_members(用于关系many2many的用户和社区).

我使用Flask-SQLAlchemy创建这个表:

community_members = db.Table('community_members',
                db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
                db.Column('community_id', db.Integer, db.ForeignKey('community.id')),
                )


class Community(db.Model):
    __tablename__ = 'community'

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False, unique=True)
    members = db.relationship(User, secondary=community_members,
                            backref=db.backref('community_members', lazy='dynamic'))

现在我想向community_members添加其他字段,如下所示:

community_members = db.Table('community_members',
                db.Column('id', db.Integer, primary_key=True),
                db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
                db.Column('community_id', db.Integer, db.ForeignKey('community.id')),
                db.Column('time_create', db.DateTime, nullable=False, default=func.now()),
                )

现在在python shell中我可以这样做:

创建社区:

> c = Community()
> c.name = 'c1'
> db.session.add(c)
> db.session.commit()

将成员添加到社区:

> u1 = User.query.get(1)
> u2 = User.query.get(2)
> c.members.append(u1)
> c.members.append(u2)
> db.session.commit() …

for item in data:
    category_id = item['category_id']
    del item['category_id']

    category = Category.objects.get(pk=category_id)

    code = item['code']

    try:
        article = Article.objects.get(pk=code)
    except:
        article = Article(**item)
        article.save()

    # at this point I have the article & category, but the next
    # statement throws me an error:
    category.articles.add(article)
    category.save()

错误是:

   AttributeError: 'ManyRelatedManager' object has no attribute 'add'

为什么Java方法名称如此广泛地使用"get"前缀？至少在我的Java程序也有很多与以单词"获取"名称的方法.get方法的百分比非常高.由于通货膨胀,我开始觉得"获得"这个词正在失去意义.这是我的代码中的噪音.

我注意到,有功能性/声明性编程和PL/SQL中使用不同的命名约定.方法名称只是说明方法返回的内容.而不是account.getAmount()或Time.getIsoFormattedDateString(Date date)他们将使用account.amount()和Time.isoFormattedDateString(Date date).这让我感觉良好,因为该函数的名称描述评估方法(假设有没有副作用,这不应该是这样)的结果."get"前缀似乎是多余的.

我刚刚开始阅读"清洁代码"一书.它说方法应该只做一件事,那件事通常应该是以下之一:

1. 通知某个事件的对象,通常将事件作为参数传递.
2. 询问有关某个对象的问题,通常使用方法名称形成自然语言语句,将对象作为参数传递并返回布尔值.
3. 获取某些内容,可能会传递一些查找键或某些要转换为参数的对象,并始终返回所需的对象/值.

我的问题是关于第三类.对于这种方法,是否存在除"get"之外的命名约定？选择方法名称/前缀时使用什么标准？

这是一个例子:

我有两个方法的类getDates()和getSpecialDates().getDates()只返回私有变量的值(对日期集合的引用).据我所知,这是一个标准的吸气剂.getSpecialDates()是不同的; 它调用getDates(),从另一个类中获取过滤器,应用过滤器并返回实际上是其子集的过滤器getDates().

该方法getSpecialDates()可以被命名为computeSpecialDates(),findSpecialDates(),selectSpecialDates()或elicitSpecialDates()或什么的.或者我可以简单地命名它specialDates().然后,为了保持一致性,我可以重新命名getDates()成dates().

为什么要分开应该以"get"为前缀的方法和不应该使用的方法,以及为什么要为"get"找到替换词呢？

我想从用户类对象创建多对多关系.

我有这样的事情:

class MyUser(models.Model):
    ...
    blocked_users = models.ManyToManyField(MyUser, blank=True, null=True)

问题是我是否可以在其内部使用类引用.或者我必须使用"self"插入"MyUser"的ManyToManyField？或者还有另一种(更好的)方法吗？