JPQL：多重连接。如何做我的命名查询？

Posted 2023-03-23

【中文标题】JPQL：多重连接。如何做我的命名查询？

【英文标题】：JPQL : multiple join. How to do my namedquery?

【发布时间】：2012-08-14 10:23:01

【问题描述】：

这是我的数据库的快速图表。

http://img17.imageshack.us/img17/2474/mpd.png

在这个方案中，我创建了 JPA 实体（对于所有带有红色方块的表）。

我想创建一个 JPQL 查询来获取所有具有引用的飞机，引用由参数给出的引用类型定义。

我试过了： SELECT DISTINCT a FROM Aircraft a JOIN FETCH a.references r WHERE EXISTS (SELECT ref FROM Reference ref WHERE ref = r AND ref.referenceType.id = :id)

但我有一个错误，因为 Eclipse 不喜欢 JOIN FETCH a.references *r* 中的别名，并且请求在 JUnit 测试中不起作用。

这里我的实体没有 getter/setter ：

飞机

@Entity
@Table(name = "T_R_AIRCRAFT_AIR", uniqueConstraints = @UniqueConstraint(columnNames = "AIR_NAME"))
public class Aircraft implements java.io.Serializable 

    @Id
    @Column(name = "AIR_ID", unique = true, nullable = false)
    @TableGenerator(name="aircraftSeqStore", 
        table="T_S_APP_SEQ_STORE_AST", 
        pkColumnName="AST_SEQ_NAME",
        valueColumnName = "AST_SEQ_VALUE",
        pkColumnValue = "T_R_AIRCRAFT_AIR.AIR_ID", 
        allocationSize=1)
    @GeneratedValue(strategy=GenerationType.TABLE, 
        generator="aircraftSeqStore")       
    private Integer id;

    @Column(name = "AIR_NAME", unique = true, nullable = false, length = 50)
    private String name;

    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(name = "T_J_REF_AIR_RFA", 
               joinColumns =  @JoinColumn(name = "RFA_AIR_ID", nullable = false, updatable = false) , 
               inverseJoinColumns =  @JoinColumn(name = "RFA_REF_ID", nullable = false, updatable = false) )
    private Set<Reference> references = new HashSet<Reference>(0);

    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(name = "T_J_MAN_AIR_MNA", 
               joinColumns =  @JoinColumn(name = "MNA_AIR_ID", nullable = false, updatable = false) , 
               inverseJoinColumns =  @JoinColumn(name = "MNA_MAN_ID", nullable = false, updatable = false) )  
    private Set<Manual> manuals = new HashSet<Manual>(0);

    @OneToMany(fetch = FetchType.LAZY, 
               mappedBy = "aircraft",
               cascade =  CascadeType.REMOVE )
    private Set<UserConfig> userConfigs = new HashSet<UserConfig>(0);

** 参考 **

@Entity
@Table(name = "T_E_REFERENCE_REF", 
       uniqueConstraints = @UniqueConstraint(columnNames = "REF_IDENTIFIER"))
public class Reference implements java.io.Serializable 

    @Id
    @Column(name = "REF_ID", unique = true, nullable = false)
    @TableGenerator(name="referenceSeqStore", 
        table="T_S_APP_SEQ_STORE_AST", 
        pkColumnName="AST_SEQ_NAME",
        valueColumnName = "AST_SEQ_VALUE",
        pkColumnValue = "T_E_REFERENCE_REF.REF_ID", 
        allocationSize=1)
    @GeneratedValue(strategy=GenerationType.TABLE, generator="referenceSeqStore")                   
    private Integer id;

    @Column(name = "REF_IDENTIFIER", unique = true, nullable = false, length = 50)  
    private String identifier;

    @Column(name = "REF_LINK")  
    private String link;

    @Column(name = "REF_OBSERVATIONS", length = 4000)
    private String observations;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "REF_RFT_ID", nullable = false)  
    private ReferenceType referenceType;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "REF_MAN_ID")    
    private Manual manual;  

    @OneToMany(fetch = FetchType.LAZY, 
               mappedBy = "reference",
               cascade =  CascadeType.REMOVE )
    private Set<Translation> translations = new HashSet<Translation>(0);

    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(name = "T_J_REF_AIR_RFA", 
               joinColumns =  @JoinColumn(name = "RFA_REF_ID", nullable = false, updatable = false) ,
               inverseJoinColumns =  @JoinColumn(name = "RFA_AIR_ID", nullable = false, updatable = false) )
    private Set<Aircraft> aircrafts = new HashSet<Aircraft>(0);

** 参考类型 **

@Entity
@Table(name = "T_R_REFERENCE_TYPE_RFT", 
       uniqueConstraints = @UniqueConstraint(columnNames = "RFT_TYPE"))
public class ReferenceType implements java.io.Serializable 

    @Id
    @Column(name = "RFT_ID", unique = true, nullable = false)
    @TableGenerator(name="referenceTypeSeqStore", 
        table="T_S_APP_SEQ_STORE_AST", 
        pkColumnName="AST_SEQ_NAME",
        valueColumnName = "AST_SEQ_VALUE",
        pkColumnValue = "T_R_REFERENCE_TYPE_RFT.RFT_ID", 
        allocationSize=1)
    @GeneratedValue(strategy=GenerationType.TABLE, generator="referenceTypeSeqStore")                   
    private Integer id;

    @Column(name = "RFT_TYPE", unique = true, nullable = false, length = 50)    
    private String type;

    @OneToMany(fetch = FetchType.LAZY, 
               mappedBy = "referenceType", 
               cascade =  CascadeType.REMOVE )    
    private Set<Reference> references = new HashSet<Reference>(0);

    @OneToMany(fetch = FetchType.LAZY, 
               mappedBy = "referenceType",
               cascade =  CascadeType.REMOVE )    
    private Set<UserConfig> userConfigs = new HashSet<UserConfig>(0);

PS：我忘了说在飞机和参考之间添加了一个表格。这是手动表。但我认为没有影响。

PS2：JPA 是由 Hibernate 实现的。

知道如何进行多重连接吗？ 谢谢！

【问题讨论】：

如何加入一个已经从一个加入的实体？即如何将 A 与 B 与 C 连接起来？似乎很容易将 A 与 B 结合，A 与 C 结合，但对于其他人来说，我没有成功。

【参考方案1】：

您可以更轻松地执行查询，如下所示：

SELECT DISTINCT a FROM Aircraft a JOIN FETCH a.references r 
LEFT JOIN FETCH a.manuals 
WHERE r.referenceType.id = :id

我添加了join fetch a.manuals，否则我得到了LazyInitializationException。新增LEFT，防止缺少手册影响输出。

【讨论】：

最后，我的 JUnit 测试有一个 pb。延迟加载太多，加载了太多集合，我的内存不足。我对 JPQL 有困难。所以我不知道我的 JPQL 是否正常工作。 JPA 验证器似乎不接受在连接提取之后放置别名。暂时你的回答不允许我理解它是如何工作的。这个 JPQL 是否正确：SELECT DISTINCT a FROM Aircraft a JOIN FETCH a.references JOIN FETCH a.references.referenceType WHERE a.references.referenceType.id = :id？感谢您的耐心等待。

不，此查询将不起作用，因为此路径 a.references.referenceType 无效。想想你自己：你引用了references 集合的referenceType 属性，后者显然没有。

我知道使用 join fetch 是为了“加载”为延迟加载配置的集合？那么是否可以创建嵌套查询？在 SQL 中，我们可能首先通过查询来选择 ReferenceType Id 的所有引用，然后通过一些关节来获取飞机（通过连接表）。

在 JPQL 中，您应该忘记连接表，因为在这里您使用 @Entities、@ElementCollections、@Embeddabbles 等。在 JPQL 中，仅当您想通过 @ManyToMany 或 @OneToMany 关联访问实体时才需要加入，就像当前情况一样。否则，如果 Aircraft 与 Reference 存在 @OneToOne 或 @ManyToOne 关联，那么您可以按如下方式制定查询：SELECT DISTINCT a FROM Aircraft a LEFT JOIN FETCH a.manuals WHERE a.reference.referenceType.id = :id

好的。谢谢你的这些解释。所以，如果我总结一下，所有@ManyToMany 和@OneToMany 关联都需要连接，但@ManyToOne 和@OneToOne....除非存在延迟加载，我们仍然需要进行连接fetch 以“加载”我们的实体。准确吗？