标签: many-to-one

我正在尝试根据product_item表中的productId和toolboxItemId选择product_item_sortorder表中的匹配行.

在适用于给定productId的普通SQL中:

SELECT pi.*, pis.* FROM product_item pi
LEFT JOIN product_item_sortorder pis
    ON pi.productId = pis.productId
    AND pi.toolboxItemId = pis.toolboxItemId
WHERE pi.productId = 6

我为它写了DQL如下:

$this->_em->createQuery(
    'SELECT pi
    FROM Entities\ProductItem pi
    LEFT JOIN pi.sequence s
    WHERE pi.product = ?1'
);

如果输出$ query-> getSQL(),我会得到以下SQL:

SELECT p0_.id AS id0, p0_.productId AS productId1, p0_.priceGroupId AS priceGroupId2, p0_.toolboxItemId AS toolboxItemId3, p0_.levelId AS levelId4, p0_.parentId AS parentId5, p0_.productId AS productId6, p0_.toolboxItemId AS toolboxItemId7 FROM product_item p0_ LEFT JOIN product_item_sortorder p1_ ON p0_.productId = p1_. AND …

我是Symfony和Doctrine的新手.

我有一个实体"用户"和一个实体"类型".一个用户可以拥有一个喜欢的类型,一个类型可以拥有许多具有该特定类型作为收藏的用户.所以我需要一个多(用户)到一个(类型)的关系.

我实现了它,它工作正常(大多数情况下).但有一件事我不明白.

如果我做这样的事情它的作用:

$user = new User();
$type = new Type();

$user->setFavoriteType($type);
$em->persist($user);
$em->persist($type);
$em->flush();

生成对象并将其存储到DB.并且正确设置了favorite_type_id.所以改变拥有方可以按预期工作.

但是如果我将用户添加到反面(仅)并刷新实体管理器,则不设置favorite_type_id.

$user = new User();
$type = new Type();

$type->getUsers()->add($user); //same with $type->addUser($user);
$em->persist($user);
$em->persist($type);
$em->flush();

这是为什么？有没有理由说它不能从反面起作用？我真的必须手动设置吗？如果我操作类型实体中的addUser方法,如"$ user-> setFavoriteType($ this)",它可以工作.但这不应该是学说的任务吗？

文件说

更新双向关联时,Doctrine仅检查双方中的一方以查找这些更改.这被称为协会的拥有方.

所以这似乎是通缉行为,是吗？但为什么？由于表现？语义原因？

如果有人可以向我解释或告诉我我做错了什么,我会很高兴的.

我有两个具有外键关系的表。我试过搜索如何做到这一点，它总是导致 OneToMany 和 ManyToOne 映射。我有这两张桌子。

用户角色

用户

我试图通过将位置列的值获取到 user_role 表来显示所有用户并显示他们的位置。

这些是我的课

用户.java

@Entity
@Table(name="user")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;

    ..........

    private UserRole userRole;

    @ManyToOne()
    @JoinColumn(name="role_id")
    public UserRole getUserRole() {
        return userRole;
    }

    public void setUserRole(UserRole userRole) {
        this.userRole = userRole;
    }

    .......
}

用户角色.java

@Entity
@Table(name="user_role")
public class UserRole {

    .......

    private List<User> user;

    @OneToMany(targetEntity=User.class, mappedBy="userRole",cascade=CascadeType.ALL, fetch = FetchType.LAZY)
    public List<User> getUser() {
        return user;
    }

    public void setUser(List<User> user) {
        this.user = user; …

我是如何在单向多对一条件下连接表格的？.

如果你有两个班:

class A {
    @Id
    public Long id;
}

class B {
    @Id
    public Long id;
    @ManyToOne
    @JoinColumn(name = "parent_id", referencedColumnName = "id")
    public A parent;
}

B - > A是多对一的关系.我知道我可以在A中添加B的集合但是我不想要这种关联.

所以我的实际问题是,是否有创建SQL查询的HQL或Criteria方法:

select * from A left join B on (b.parent_id = a.id)

这将检索具有引用A的每个B记录的笛卡尔积的所有A记录,并且将包括没有B引用它们的A记录.

如果您使用:

from A a, B b where b.a = a

那么它是一个内连接,你没有收到没有B引用它们的A记录.

我没有找到一个没有两个查询的好方法,所以任何不到这个都会很好.

谢谢.

我有两个实体:

@Entity
public class File
.......
@Id @GeneratedValue(strategy=GenerationType.AUTO)
private int id;
@OneToMany(fetch=FetchType.LAZY, mappedBy="file", cascade=CascadeType.ALL)
private List<Tag> tags;
.......
OTHER PROPERTIES
.......

@Entity
public class Tag
.......
@Id @GeneratedValue(strategy=GenerationType.AUTO)
private int id;
@ManyToOne
@JoinColumn(name="file_id")
private File file;
@Column
private String tag;
.......
OTHER PROPERTIES
.......

我试图通过执行以下操作插入到File(以及随后的Tag)中:

File file = new File();
Tag tag = new Tag();
tag.setTag("tag1");
Tag2 tag2 = new Tag();
tag2.setTag("tag2");
List<Tag> tags = new ArrayList<Tag>();
tags.add(tag);
tags.add(tag2);
file.setTags(tags);
---Add other file attributes here---

然后我使用以下命令在我的DAO中插入文件:

sessionFactory.getCurrentSession().saveOrUpdate(file); 

在我的日志中,我看到插入到我的"文件"表中,并且在我的标记表中插入了2个,但是,我的标记表中指向我的文件表(file_id)的外键是NULL.

我怎么可能做错了？

我问并回答我自己的问题,但我不认为我有最好的答案.如果你有一个更好的,请发布它!

相关问题:

• 如何在JPA中设置@EmbeddedId的反向引用
• hibernate映射whereid(？)
• 带@EmbeddedId的JPA复合键

我有一对处于简单聚合关系的类:任何一个实例都拥有另一个实例.拥有类具有自己的某种主键,并且拥有的类通过相应的外键与该类具有多对一.我希望拥有的类具有包含该外键的主键以及一些附加信息.

为了争论,让我们使用那些常年的最爱,Order和OrderLine.

SQL看起来像这样:

-- 'order' may have been a poor choice of name, given that it's an SQL keyword!
create table Order_ (
    orderId integer primary key
);
create table OrderLine (
    orderId integer not null references Order_,
    lineNo integer not null,
    primary key (orderId, lineNo)
);

我想使用JPA将其映射到Java.订单很简单,OrderLine可以用@IdClass处理.这是代码 - 代码相当传统,我希望你会原谅我的特质.

但是,使用@IdClass涉及编写ID类,该类复制OrderLine中的字段.我想避免重复,所以我想使用@EmbeddedId.

然而,一个天真的尝试这样做失败了:

@Embeddable
public class OrderLineKey {
    @ManyToOne
    private Order order;
    private int lineNo;
}

OpenJPA拒绝将其用作@EmbeddedId.我没有尝试过其他提供程序,但我不希望它们成功,因为JPA规范要求构成ID类的字段是基本的,而不是关系.

那么,我该怎么办？我如何编写一个其键包含@ManyToOne关系的类,但是作为@EmbeddedId处理？

所以,这是我第一次学习计算机语言.我选择了python和django.现在,我得到了许多python和django的基本概念.我可以创建包含视图和所有其他内容的新页面.但我仍然对这种关系感到困惑,即一对一,多对一,多对多.有人请请向我解释.我怎么用呢？我真的需要知道.

谢谢.

我有以下带注释的Hibernate实体类:

@Entity
public class Cat {
    @Column(name = "ID") @GeneratedValue(strategy = GenerationType.AUTO) @Id
    private Long id;

    @OneToMany(mappedBy = "cat", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    private Set<Kitten> kittens = new HashSet<Kitten>();

    public void setId(Long id) { this.id = id; }
    public Long getId() { return id; }
    public void setKittens(Set<Kitten> kittens) { this.kittens = kittens; }
    public Set<Kitten> getKittens() { return kittens; }
}

@Entity
public class Kitten {
    @Column(name = "ID") @GeneratedValue(strategy = GenerationType.AUTO) @Id
    private Long id;

    @ManyToOne(cascade …

尽管我的问题专门针对使用Hibernate的Play框架中描述实体关系的方式,但我确信这是一般概念.

当我们有一对多关系时,我们总是被要求指定拥有方.

所以,例如,如果我们在Person和PhoneNumber之间有一对多的关系,我们就会编写这样的代码.

@Entity
class Person {
    @OneToMany(mappedBy="person")
    public Set<PhoneNumber> phoneNumbers;
}

@Entity
class PhoneNumber {
    @ManyToOne
    public Person person;
}

在上面的代码中,拥有实体是PhoneNumber.任何一方作为拥有实体的利弊是什么？

我知道当拥有的实体是PhoneNUmber时,表示的关系是ManyToOne,它不会产生连接表,而当拥有方是Person时,描述的关系将是OneToMany,在这种情况下将创建关系表.

这是确定拥有方的主要原因,还是还有其他原因？

更新: 我刚刚意识到这个线程提供了部分答案,但我希望也可能有其他要点.

我有这些课程：

@Entity
public class Invoice implements Serializable {
    @Id
    @Basic(optional = false)
    private Integer number;

    private BigDecimal value;

    //Getters and setters
}

@Entity
public class InvoiceItem implements Serializable {
    @EmbeddedId
    protected InvoiceItemPK invoiceItemPk;

    @ManyToOne
    @JoinColumn(name = "invoice_number", insertable = false, updatable = false)
    private Invoice invoice;

    //Getters and setters
}

当我运行此查询时：

session.createQuery("select i from InvoiceItem i").list();

它执行一个查询以从 InvoiceItem 中选择记录，如果我有 10000 个发票项目，它会生成 10000 个附加查询以从每个 InvoiceItem 中选择发票。

我认为如果可以在单个 sql 中获取所有记录会好得多。实际上，我觉得奇怪为什么它不是默认行为。

那么，我该怎么做呢？